dlls/wintrust/softpub.c

   1 /*
   2  * Copyright 2007 Juan Lang
   3  * Copyright 2016 Mark Jansen
   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 <stdarg.h>
  21
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winternl.h"
  25 #include "wintrust.h"
  26 #include "mssip.h"
  27 #include "softpub.h"
  28 #include "winnls.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wintrust);
  32
  33 HRESULT WINAPI SoftpubDefCertInit(CRYPT_PROVIDER_DATA *data)
  34 {
  35     HRESULT ret = S_FALSE;
  36
  37     TRACE("(%p)\n", data);
  38
  39     if (data->padwTrustStepErrors &&
  40      !data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_WVTINIT])
  41         ret = S_OK;
  42     TRACE("returning %08lx\n", ret);
  43     return ret;
  44 }
  45
  46 HRESULT WINAPI SoftpubInitialize(CRYPT_PROVIDER_DATA *data)
  47 {
  48     HRESULT ret = S_FALSE;
  49
  50     TRACE("(%p)\n", data);
  51
  52     if (data->padwTrustStepErrors &&
  53      !data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_WVTINIT])
  54         ret = S_OK;
  55     TRACE("returning %08lx\n", ret);
  56     return ret;
  57 }
  58
  59 HRESULT WINAPI DriverInitializePolicy(CRYPT_PROVIDER_DATA *data)
  60 {
  61     FIXME("stub\n");
  62     return S_OK;
  63 }
  64
  65 HRESULT WINAPI DriverCleanupPolicy(CRYPT_PROVIDER_DATA *data)
  66 {
  67     FIXME("stub\n");
  68     return S_OK;
  69 }
  70
  71 HRESULT WINAPI DriverFinalPolicy(CRYPT_PROVIDER_DATA *data)
  72 {
  73     FIXME("stub\n");
  74     return S_OK;
  75 }
  76
  77 /* Assumes data->pWintrustData->u.pFile exists.  Makes sure a file handle is
  78  * open for the file.
  79  */
  80 static DWORD SOFTPUB_OpenFile(CRYPT_PROVIDER_DATA *data)
  81 {
  82     DWORD err = ERROR_SUCCESS;
  83
  84     /* PSDK implies that all values should be initialized to NULL, so callers
  85      * typically have hFile as NULL rather than INVALID_HANDLE_VALUE.  Check
  86      * for both.
  87      */
  88     if (!data->pWintrustData->pFile->hFile ||
  89      data->pWintrustData->pFile->hFile == INVALID_HANDLE_VALUE)
  90     {
  91         data->pWintrustData->pFile->hFile =
  92             CreateFileW(data->pWintrustData->pFile->pcwszFilePath, GENERIC_READ,
  93           FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  94         if (data->pWintrustData->pFile->hFile != INVALID_HANDLE_VALUE)
  95             data->fOpenedFile = TRUE;
  96         else
  97             err = GetLastError();
  98     }
  99     if (!err)
 100         GetFileTime(data->pWintrustData->pFile->hFile, &data->sftSystemTime,
 101          NULL, NULL);
 102     TRACE("returning %ld\n", err);
 103     return err;
 104 }
 105
 106 /* Assumes data->pWintrustData->pFile exists.  Sets data->pPDSip->gSubject to
 107  * the file's subject GUID.
 108  */
 109 static DWORD SOFTPUB_GetFileSubject(CRYPT_PROVIDER_DATA *data)
 110 {
 111     DWORD err = ERROR_SUCCESS;
 112
 113     if (!WVT_ISINSTRUCT(WINTRUST_FILE_INFO,
 114      data->pWintrustData->pFile->cbStruct, pgKnownSubject) ||
 115      !data->pWintrustData->pFile->pgKnownSubject)
 116     {
 117         if (!CryptSIPRetrieveSubjectGuid(
 118          data->pWintrustData->pFile->pcwszFilePath,
 119          data->pWintrustData->pFile->hFile,
 120          &data->pPDSip->gSubject))
 121         {
 122             LARGE_INTEGER fileSize;
 123             DWORD sipError = GetLastError();
 124
 125             /* Special case for empty files: the error is expected to be
 126              * TRUST_E_SUBJECT_FORM_UNKNOWN, rather than whatever
 127              * CryptSIPRetrieveSubjectGuid returns.
 128              */
 129             if (GetFileSizeEx(data->pWintrustData->pFile->hFile, &fileSize)
 130              && !fileSize.QuadPart)
 131                 err = TRUST_E_SUBJECT_FORM_UNKNOWN;
 132             else
 133                 err = sipError;
 134         }
 135     }
 136     else
 137         data->pPDSip->gSubject = *data->pWintrustData->pFile->pgKnownSubject;
 138     TRACE("returning %ld\n", err);
 139     return err;
 140 }
 141
 142 /* Assumes data->pPDSip exists, and its gSubject member set.
 143  * Allocates data->pPDSip->pSip and loads it, if possible.
 144  */
 145 static DWORD SOFTPUB_GetSIP(CRYPT_PROVIDER_DATA *data)
 146 {
 147     DWORD err = ERROR_SUCCESS;
 148
 149     data->pPDSip->pSip = data->psPfns->pfnAlloc(sizeof(SIP_DISPATCH_INFO));
 150     if (data->pPDSip->pSip)
 151     {
 152         if (!CryptSIPLoad(&data->pPDSip->gSubject, 0, data->pPDSip->pSip))
 153             err = GetLastError();
 154     }
 155     else
 156         err = ERROR_OUTOFMEMORY;
 157     TRACE("returning %ld\n", err);
 158     return err;
 159 }
 160
 161 /* Assumes data->pPDSip has been loaded, and data->pPDSip->pSip allocated.
 162  * Calls data->pPDSip->pSip->pfGet to construct data->hMsg.
 163  */
 164 static DWORD SOFTPUB_GetMessageFromFile(CRYPT_PROVIDER_DATA *data, HANDLE file,
 165  LPCWSTR filePath)
 166 {
 167     DWORD err = ERROR_SUCCESS;
 168     BOOL ret;
 169     LPBYTE buf = NULL;
 170     DWORD size = 0;
 171
 172     data->pPDSip->psSipSubjectInfo =
 173      data->psPfns->pfnAlloc(sizeof(SIP_SUBJECTINFO));
 174     if (!data->pPDSip->psSipSubjectInfo)
 175         return ERROR_OUTOFMEMORY;
 176
 177     data->pPDSip->psSipSubjectInfo->cbSize = sizeof(SIP_SUBJECTINFO);
 178     data->pPDSip->psSipSubjectInfo->pgSubjectType = &data->pPDSip->gSubject;
 179     data->pPDSip->psSipSubjectInfo->hFile = file;
 180     data->pPDSip->psSipSubjectInfo->pwsFileName = filePath;
 181     data->pPDSip->psSipSubjectInfo->hProv = data->hProv;
 182     ret = data->pPDSip->pSip->pfGet(data->pPDSip->psSipSubjectInfo,
 183      &data->dwEncoding, 0, &size, 0);
 184     if (!ret)
 185         return TRUST_E_NOSIGNATURE;
 186
 187     buf = data->psPfns->pfnAlloc(size);
 188     if (!buf)
 189         return ERROR_OUTOFMEMORY;
 190
 191     ret = data->pPDSip->pSip->pfGet(data->pPDSip->psSipSubjectInfo,
 192      &data->dwEncoding, 0, &size, buf);
 193     if (ret)
 194     {
 195         data->hMsg = CryptMsgOpenToDecode(data->dwEncoding, 0, 0, data->hProv,
 196          NULL, NULL);
 197         if (data->hMsg)
 198         {
 199             ret = CryptMsgUpdate(data->hMsg, buf, size, TRUE);
 200             if (!ret)
 201                 err = GetLastError();
 202         }
 203     }
 204     else
 205         err = GetLastError();
 206
 207     data->psPfns->pfnFree(buf);
 208     TRACE("returning %ld\n", err);
 209     return err;
 210 }
 211
 212 static BOOL hash_file_data( HANDLE file, DWORD start, DWORD end, HCRYPTHASH hash )
 213 {
 214     DWORD bytes_read, size = end - start;
 215     DWORD buffer_size = min( size, 1024*1024 );
 216     BYTE *buffer = malloc( buffer_size );
 217
 218     if (!buffer) return FALSE;
 219     SetFilePointer( file, start, NULL, FILE_BEGIN );
 220     while (size)
 221     {
 222         if (!ReadFile( file, buffer, min( buffer_size, size ), &bytes_read, NULL )) break;
 223         if (!bytes_read) break;
 224         if (!CryptHashData( hash, buffer, bytes_read, 0 )) break;
 225         size -= bytes_read;
 226     }
 227     free( buffer );
 228     return !size;
 229 }
 230
 231 /* See https://www.cs.auckland.ac.nz/~pgut001/pubs/authenticode.txt
 232  * for details about the hashing.
 233  */
 234 static BOOL SOFTPUB_HashPEFile(HANDLE file, HCRYPTHASH hash)
 235 {
 236     DWORD checksum, security_dir;
 237     IMAGE_DOS_HEADER dos_header;
 238     union
 239     {
 240         IMAGE_NT_HEADERS32 nt32;
 241         IMAGE_NT_HEADERS64 nt64;
 242     } nt_header;
 243     IMAGE_DATA_DIRECTORY secdir;
 244     LARGE_INTEGER file_size;
 245     DWORD bytes_read;
 246     BOOL ret;
 247
 248     if (!GetFileSizeEx(file, &file_size))
 249         return FALSE;
 250
 251     SetFilePointer(file, 0, NULL, FILE_BEGIN);
 252     ret = ReadFile(file, &dos_header, sizeof(dos_header), &bytes_read, NULL);
 253     if (!ret || bytes_read != sizeof(dos_header))
 254         return FALSE;
 255
 256     if (dos_header.e_magic != IMAGE_DOS_SIGNATURE)
 257         return FALSE;
 258     if (dos_header.e_lfanew >= 256 * 1024 * 1024) /* see RtlImageNtHeaderEx */
 259         return FALSE;
 260     if (dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader.MajorLinkerVersion) > file_size.QuadPart)
 261         return FALSE;
 262
 263     SetFilePointer(file, dos_header.e_lfanew, NULL, FILE_BEGIN);
 264     ret = ReadFile(file, &nt_header, sizeof(nt_header), &bytes_read, NULL);
 265     if (!ret || bytes_read < FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader.Magic) +
 266                              sizeof(nt_header.nt32.OptionalHeader.Magic))
 267         return FALSE;
 268
 269     if (nt_header.nt32.Signature != IMAGE_NT_SIGNATURE)
 270         return FALSE;
 271
 272     if (nt_header.nt32.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)
 273     {
 274         if (bytes_read < sizeof(nt_header.nt32))
 275             return FALSE;
 276
 277         checksum     = dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader.CheckSum);
 278         security_dir = dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]);
 279         secdir       = nt_header.nt32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY];
 280     }
 281     else if (nt_header.nt32.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
 282     {
 283         if (bytes_read < sizeof(nt_header.nt64))
 284             return FALSE;
 285
 286         checksum     = dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS64, OptionalHeader.CheckSum);
 287         security_dir = dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS64, OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]);
 288         secdir       = nt_header.nt64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY];
 289     }
 290     else
 291         return FALSE;
 292
 293     if (secdir.VirtualAddress < security_dir + sizeof(IMAGE_DATA_DIRECTORY))
 294         return FALSE;
 295     if (secdir.VirtualAddress > file_size.QuadPart)
 296         return FALSE;
 297     if (secdir.VirtualAddress + secdir.Size != file_size.QuadPart)
 298         return FALSE;
 299
 300     if (!hash_file_data( file, 0, checksum, hash )) return FALSE;
 301     if (!hash_file_data( file, checksum + sizeof(DWORD), security_dir, hash )) return FALSE;
 302     if (!hash_file_data( file, security_dir + sizeof(IMAGE_DATA_DIRECTORY), secdir.VirtualAddress, hash ))
 303         return FALSE;
 304
 305     return TRUE;
 306 }
 307
 308 static DWORD SOFTPUB_VerifyImageHash(CRYPT_PROVIDER_DATA *data, HANDLE file)
 309 {
 310     SPC_INDIRECT_DATA_CONTENT *indirect = (SPC_INDIRECT_DATA_CONTENT *)data->pPDSip->psIndirectData;
 311     DWORD err, hash_size, length;
 312     BYTE *hash_data;
 313     BOOL release_prov = FALSE;
 314     HCRYPTPROV prov = data->hProv;
 315     HCRYPTHASH hash = 0;
 316     ALG_ID algID;
 317
 318     if (((ULONG_PTR)indirect->Data.pszObjId >> 16) == 0 ||
 319         strcmp(indirect->Data.pszObjId, SPC_PE_IMAGE_DATA_OBJID))
 320     {
 321         FIXME("Cannot verify hash for pszObjId=%s\n", debugstr_a(indirect->Data.pszObjId));
 322         return ERROR_SUCCESS;
 323     }
 324
 325     if (!(algID = CertOIDToAlgId(indirect->DigestAlgorithm.pszObjId)))
 326         return TRUST_E_SYSTEM_ERROR; /* FIXME */
 327
 328     if (!prov)
 329     {
 330         if (!CryptAcquireContextW(&prov, NULL, MS_ENH_RSA_AES_PROV_W, PROV_RSA_AES, CRYPT_VERIFYCONTEXT))
 331             return GetLastError();
 332         release_prov = TRUE;
 333     }
 334
 335     if (!CryptCreateHash(prov, algID, 0, 0, &hash))
 336     {
 337         err = GetLastError();
 338         goto done;
 339     }
 340
 341     if (!SOFTPUB_HashPEFile(file, hash))
 342     {
 343         err = TRUST_E_NOSIGNATURE;
 344         goto done;
 345     }
 346
 347     length = sizeof(hash_size);
 348     if (!CryptGetHashParam(hash, HP_HASHSIZE, (BYTE *)&hash_size, &length, 0))
 349     {
 350         err = GetLastError();
 351         goto done;
 352     }
 353
 354     if (!(hash_data = data->psPfns->pfnAlloc(hash_size)))
 355     {
 356         err = ERROR_OUTOFMEMORY;
 357         goto done;
 358     }
 359
 360     if (!CryptGetHashParam(hash, HP_HASHVAL, hash_data, &hash_size, 0))
 361     {
 362         err = GetLastError();
 363         data->psPfns->pfnFree(hash_data);
 364         goto done;
 365     }
 366
 367     err = (hash_size == indirect->Digest.cbData &&
 368            !memcmp(hash_data, indirect->Digest.pbData, hash_size)) ? S_OK : TRUST_E_BAD_DIGEST;
 369     data->psPfns->pfnFree(hash_data);
 370
 371 done:
 372     if (hash)
 373         CryptDestroyHash(hash);
 374     if (release_prov)
 375         CryptReleaseContext(prov, 0);
 376     return err;
 377 }
 378
 379
 380 static DWORD SOFTPUB_CreateStoreFromMessage(CRYPT_PROVIDER_DATA *data)
 381 {
 382     DWORD err = ERROR_SUCCESS;
 383     HCERTSTORE store;
 384
 385     store = CertOpenStore(CERT_STORE_PROV_MSG, data->dwEncoding,
 386      data->hProv, CERT_STORE_NO_CRYPT_RELEASE_FLAG, data->hMsg);
 387     if (store)
 388     {
 389         if (!data->psPfns->pfnAddStore2Chain(data, store))
 390             err = GetLastError();
 391         CertCloseStore(store, 0);
 392     }
 393     else
 394         err = GetLastError();
 395     TRACE("returning %ld\n", err);
 396     return err;
 397 }
 398
 399 static DWORD SOFTPUB_DecodeInnerContent(CRYPT_PROVIDER_DATA *data)
 400 {
 401     BOOL ret;
 402     DWORD size, err = ERROR_SUCCESS;
 403     LPSTR oid = NULL;
 404     LPBYTE buf = NULL;
 405
 406     ret = CryptMsgGetParam(data->hMsg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, NULL,
 407      &size);
 408     if (!ret)
 409     {
 410         err = GetLastError();
 411         goto error;
 412     }
 413     oid = data->psPfns->pfnAlloc(size);
 414     if (!oid)
 415     {
 416         err = ERROR_OUTOFMEMORY;
 417         goto error;
 418     }
 419     ret = CryptMsgGetParam(data->hMsg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, oid,
 420      &size);
 421     if (!ret)
 422     {
 423         err = GetLastError();
 424         goto error;
 425     }
 426     ret = CryptMsgGetParam(data->hMsg, CMSG_CONTENT_PARAM, 0, NULL, &size);
 427     if (!ret)
 428     {
 429         err = GetLastError();
 430         goto error;
 431     }
 432     buf = data->psPfns->pfnAlloc(size);
 433     if (!buf)
 434     {
 435         err = ERROR_OUTOFMEMORY;
 436         goto error;
 437     }
 438     ret = CryptMsgGetParam(data->hMsg, CMSG_CONTENT_PARAM, 0, buf, &size);
 439     if (!ret)
 440     {
 441         err = GetLastError();
 442         goto error;
 443     }
 444     ret = CryptDecodeObject(data->dwEncoding, oid, buf, size, 0, NULL, &size);
 445     if (!ret)
 446     {
 447         err = GetLastError();
 448         goto error;
 449     }
 450     data->pPDSip->psIndirectData = data->psPfns->pfnAlloc(size);
 451     if (!data->pPDSip->psIndirectData)
 452     {
 453         err = ERROR_OUTOFMEMORY;
 454         goto error;
 455     }
 456     ret = CryptDecodeObject(data->dwEncoding, oid, buf, size, 0,
 457      data->pPDSip->psIndirectData, &size);
 458     if (!ret)
 459         err = GetLastError();
 460
 461 error:
 462     TRACE("returning %ld\n", err);
 463     data->psPfns->pfnFree(oid);
 464     data->psPfns->pfnFree(buf);
 465     return err;
 466 }
 467
 468 static DWORD SOFTPUB_LoadCertMessage(CRYPT_PROVIDER_DATA *data)
 469 {
 470     DWORD err = ERROR_SUCCESS;
 471
 472     if (data->pWintrustData->pCert &&
 473      WVT_IS_CBSTRUCT_GT_MEMBEROFFSET(WINTRUST_CERT_INFO,
 474      data->pWintrustData->pCert->cbStruct, psCertContext))
 475     {
 476         if (data->psPfns)
 477         {
 478             CRYPT_PROVIDER_SGNR signer = { sizeof(signer), { 0 } };
 479             DWORD i;
 480             BOOL ret;
 481
 482             /* Add a signer with nothing but the time to verify, so we can
 483              * add a cert to it
 484              */
 485             if (WVT_ISINSTRUCT(WINTRUST_CERT_INFO,
 486              data->pWintrustData->pCert->cbStruct, psftVerifyAsOf) &&
 487              data->pWintrustData->pCert->psftVerifyAsOf)
 488                 data->sftSystemTime = signer.sftVerifyAsOf;
 489             else
 490             {
 491                 SYSTEMTIME sysTime;
 492
 493                 GetSystemTime(&sysTime);
 494                 SystemTimeToFileTime(&sysTime, &signer.sftVerifyAsOf);
 495             }
 496             ret = data->psPfns->pfnAddSgnr2Chain(data, FALSE, 0, &signer);
 497             if (ret)
 498             {
 499                 ret = data->psPfns->pfnAddCert2Chain(data, 0, FALSE, 0,
 500                  data->pWintrustData->pCert->psCertContext);
 501                 if (WVT_ISINSTRUCT(WINTRUST_CERT_INFO,
 502                  data->pWintrustData->pCert->cbStruct, pahStores))
 503                         for (i = 0;
 504                          ret && i < data->pWintrustData->pCert->chStores; i++)
 505                             ret = data->psPfns->pfnAddStore2Chain(data,
 506                              data->pWintrustData->pCert->pahStores[i]);
 507             }
 508             if (!ret)
 509                 err = GetLastError();
 510         }
 511     }
 512     else
 513         err = ERROR_INVALID_PARAMETER;
 514     return err;
 515 }
 516
 517 static DWORD SOFTPUB_LoadFileMessage(CRYPT_PROVIDER_DATA *data)
 518 {
 519     DWORD err = ERROR_SUCCESS;
 520
 521     if (!data->pWintrustData->pFile)
 522     {
 523         err = ERROR_INVALID_PARAMETER;
 524         goto error;
 525     }
 526     err = SOFTPUB_OpenFile(data);
 527     if (err)
 528         goto error;
 529     err = SOFTPUB_GetFileSubject(data);
 530     if (err)
 531         goto error;
 532     err = SOFTPUB_GetSIP(data);
 533     if (err)
 534         goto error;
 535     err = SOFTPUB_GetMessageFromFile(data, data->pWintrustData->pFile->hFile,
 536      data->pWintrustData->pFile->pcwszFilePath);
 537     if (err)
 538         goto error;
 539     err = SOFTPUB_CreateStoreFromMessage(data);
 540     if (err)
 541         goto error;
 542     err = SOFTPUB_DecodeInnerContent(data);
 543     if (err)
 544         goto error;
 545     err = SOFTPUB_VerifyImageHash(data, data->pWintrustData->pFile->hFile);
 546
 547 error:
 548     if (err && data->fOpenedFile && data->pWintrustData->pFile)
 549     {
 550         /* The caller won't expect the file to be open on failure, so close it.
 551          */
 552         CloseHandle(data->pWintrustData->pFile->hFile);
 553         data->pWintrustData->pFile->hFile = INVALID_HANDLE_VALUE;
 554         data->fOpenedFile = FALSE;
 555     }
 556     return err;
 557 }
 558
 559 static DWORD SOFTPUB_LoadCatalogMessage(CRYPT_PROVIDER_DATA *data)
 560 {
 561     DWORD err;
 562     HANDLE catalog = INVALID_HANDLE_VALUE;
 563
 564     if (!data->pWintrustData->pCatalog)
 565     {
 566         SetLastError(ERROR_INVALID_PARAMETER);
 567         return FALSE;
 568     }
 569     catalog = CreateFileW(data->pWintrustData->pCatalog->pcwszCatalogFilePath,
 570      GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
 571      NULL);
 572     if (catalog == INVALID_HANDLE_VALUE)
 573         return GetLastError();
 574     if (!CryptSIPRetrieveSubjectGuid(
 575      data->pWintrustData->pCatalog->pcwszCatalogFilePath, catalog,
 576      &data->pPDSip->gSubject))
 577     {
 578         err = GetLastError();
 579         goto error;
 580     }
 581     err = SOFTPUB_GetSIP(data);
 582     if (err)
 583         goto error;
 584     err = SOFTPUB_GetMessageFromFile(data, catalog,
 585      data->pWintrustData->pCatalog->pcwszCatalogFilePath);
 586     if (err)
 587         goto error;
 588     err = SOFTPUB_CreateStoreFromMessage(data);
 589     if (err)
 590         goto error;
 591     err = SOFTPUB_DecodeInnerContent(data);
 592     /* FIXME: this loads the catalog file, but doesn't validate the member. */
 593 error:
 594     CloseHandle(catalog);
 595     return err;
 596 }
 597
 598 HRESULT WINAPI SoftpubLoadMessage(CRYPT_PROVIDER_DATA *data)
 599 {
 600     DWORD err = ERROR_SUCCESS;
 601
 602     TRACE("(%p)\n", data);
 603
 604     if (!data->padwTrustStepErrors)
 605         return S_FALSE;
 606
 607     switch (data->pWintrustData->dwUnionChoice)
 608     {
 609     case WTD_CHOICE_CERT:
 610         err = SOFTPUB_LoadCertMessage(data);
 611         break;
 612     case WTD_CHOICE_FILE:
 613         err = SOFTPUB_LoadFileMessage(data);
 614         break;
 615     case WTD_CHOICE_CATALOG:
 616         err = SOFTPUB_LoadCatalogMessage(data);
 617         break;
 618     default:
 619         FIXME("unimplemented for %ld\n", data->pWintrustData->dwUnionChoice);
 620         err = ERROR_INVALID_PARAMETER;
 621     }
 622
 623     if (err)
 624         data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] = err;
 625     TRACE("returning %ld (%08lx)\n", !err ? S_OK : S_FALSE,
 626      data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV]);
 627     return !err ? S_OK : S_FALSE;
 628 }
 629
 630 static CMSG_SIGNER_INFO *WINTRUST_GetSigner(CRYPT_PROVIDER_DATA *data,
 631  DWORD signerIdx)
 632 {
 633     BOOL ret;
 634     CMSG_SIGNER_INFO *signerInfo = NULL;
 635     DWORD size;
 636
 637     ret = CryptMsgGetParam(data->hMsg, CMSG_SIGNER_INFO_PARAM, signerIdx,
 638      NULL, &size);
 639     if (ret)
 640     {
 641         signerInfo = data->psPfns->pfnAlloc(size);
 642         if (signerInfo)
 643         {
 644             ret = CryptMsgGetParam(data->hMsg, CMSG_SIGNER_INFO_PARAM,
 645              signerIdx, signerInfo, &size);
 646             if (!ret)
 647             {
 648                 data->psPfns->pfnFree(signerInfo);
 649                 signerInfo = NULL;
 650             }
 651         }
 652         else
 653             SetLastError(ERROR_OUTOFMEMORY);
 654     }
 655     return signerInfo;
 656 }
 657
 658 static BOOL WINTRUST_GetTimeFromCounterSigner(
 659  const CMSG_CMS_SIGNER_INFO *counterSignerInfo, FILETIME *time)
 660 {
 661     DWORD i;
 662     BOOL foundTimeStamp = FALSE;
 663
 664     for (i = 0; !foundTimeStamp && i < counterSignerInfo->AuthAttrs.cAttr; i++)
 665     {
 666         if (!strcmp(counterSignerInfo->AuthAttrs.rgAttr[i].pszObjId,
 667          szOID_RSA_signingTime))
 668         {
 669             const CRYPT_ATTRIBUTE *attr =
 670              &counterSignerInfo->AuthAttrs.rgAttr[i];
 671             DWORD j;
 672
 673             for (j = 0; !foundTimeStamp && j < attr->cValue; j++)
 674             {
 675                 static const DWORD encoding = X509_ASN_ENCODING |
 676                  PKCS_7_ASN_ENCODING;
 677                 DWORD size = sizeof(FILETIME);
 678
 679                 foundTimeStamp = CryptDecodeObjectEx(encoding,
 680                  X509_CHOICE_OF_TIME,
 681                  attr->rgValue[j].pbData, attr->rgValue[j].cbData, 0, NULL,
 682                  time, &size);
 683             }
 684         }
 685     }
 686     return foundTimeStamp;
 687 }
 688
 689 static LPCSTR filetime_to_str(const FILETIME *time)
 690 {
 691     static char date[80];
 692     char dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
 693     SYSTEMTIME sysTime;
 694
 695     if (!time) return NULL;
 696
 697     GetLocaleInfoA(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt, ARRAY_SIZE(dateFmt));
 698     FileTimeToSystemTime(time, &sysTime);
 699     GetDateFormatA(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date, ARRAY_SIZE(date));
 700     return date;
 701 }
 702
 703 static FILETIME WINTRUST_GetTimeFromSigner(const CRYPT_PROVIDER_DATA *data,
 704  const CMSG_SIGNER_INFO *signerInfo)
 705 {
 706     DWORD i;
 707     FILETIME time;
 708     BOOL foundTimeStamp = FALSE;
 709
 710     for (i = 0; !foundTimeStamp && i < signerInfo->UnauthAttrs.cAttr; i++)
 711     {
 712         if (!strcmp(signerInfo->UnauthAttrs.rgAttr[i].pszObjId,
 713          szOID_RSA_counterSign))
 714         {
 715             const CRYPT_ATTRIBUTE *attr = &signerInfo->UnauthAttrs.rgAttr[i];
 716             DWORD j;
 717
 718             for (j = 0; j < attr->cValue; j++)
 719             {
 720                 static const DWORD encoding = X509_ASN_ENCODING |
 721                  PKCS_7_ASN_ENCODING;
 722                 CMSG_CMS_SIGNER_INFO *counterSignerInfo;
 723                 DWORD size;
 724                 BOOL ret = CryptDecodeObjectEx(encoding, CMS_SIGNER_INFO,
 725                  attr->rgValue[j].pbData, attr->rgValue[j].cbData,
 726                  CRYPT_DECODE_ALLOC_FLAG, NULL, &counterSignerInfo, &size);
 727                 if (ret)
 728                 {
 729                     /* FIXME: need to verify countersigner signature too */
 730                     foundTimeStamp = WINTRUST_GetTimeFromCounterSigner(
 731                      counterSignerInfo, &time);
 732                     LocalFree(counterSignerInfo);
 733                 }
 734             }
 735         }
 736     }
 737     if (!foundTimeStamp)
 738     {
 739         TRACE("returning system time %s\n",
 740          filetime_to_str(&data->sftSystemTime));
 741         time = data->sftSystemTime;
 742     }
 743     else
 744         TRACE("returning time from message %s\n", filetime_to_str(&time));
 745     return time;
 746 }
 747
 748 static DWORD WINTRUST_SaveSigner(CRYPT_PROVIDER_DATA *data, DWORD signerIdx)
 749 {
 750     DWORD err;
 751     CMSG_SIGNER_INFO *signerInfo = WINTRUST_GetSigner(data, signerIdx);
 752
 753     if (signerInfo)
 754     {
 755         CRYPT_PROVIDER_SGNR sgnr = { sizeof(sgnr), { 0 } };
 756
 757         sgnr.psSigner = signerInfo;
 758         sgnr.sftVerifyAsOf = WINTRUST_GetTimeFromSigner(data, signerInfo);
 759         if (!data->psPfns->pfnAddSgnr2Chain(data, FALSE, signerIdx, &sgnr))
 760             err = GetLastError();
 761         else
 762             err = ERROR_SUCCESS;
 763     }
 764     else
 765         err = GetLastError();
 766     return err;
 767 }
 768
 769 static CERT_INFO *WINTRUST_GetSignerCertInfo(CRYPT_PROVIDER_DATA *data,
 770  DWORD signerIdx)
 771 {
 772     BOOL ret;
 773     CERT_INFO *certInfo = NULL;
 774     DWORD size;
 775
 776     ret = CryptMsgGetParam(data->hMsg, CMSG_SIGNER_CERT_INFO_PARAM, signerIdx,
 777      NULL, &size);
 778     if (ret)
 779     {
 780         certInfo = data->psPfns->pfnAlloc(size);
 781         if (certInfo)
 782         {
 783             ret = CryptMsgGetParam(data->hMsg, CMSG_SIGNER_CERT_INFO_PARAM,
 784              signerIdx, certInfo, &size);
 785             if (!ret)
 786             {
 787                 data->psPfns->pfnFree(certInfo);
 788                 certInfo = NULL;
 789             }
 790         }
 791         else
 792             SetLastError(ERROR_OUTOFMEMORY);
 793     }
 794     return certInfo;
 795 }
 796
 797 static DWORD WINTRUST_VerifySigner(CRYPT_PROVIDER_DATA *data, DWORD signerIdx)
 798 {
 799     DWORD err;
 800     CERT_INFO *certInfo = WINTRUST_GetSignerCertInfo(data, signerIdx);
 801
 802     if (certInfo)
 803     {
 804         PCCERT_CONTEXT subject = CertGetSubjectCertificateFromStore(
 805          data->pahStores[0], data->dwEncoding, certInfo);
 806
 807         if (subject)
 808         {
 809             CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA para = { sizeof(para), 0,
 810              signerIdx, CMSG_VERIFY_SIGNER_CERT, (LPVOID)subject };
 811
 812             if (!CryptMsgControl(data->hMsg, 0, CMSG_CTRL_VERIFY_SIGNATURE_EX,
 813              &para))
 814                 err = TRUST_E_CERT_SIGNATURE;
 815             else
 816             {
 817                 data->psPfns->pfnAddCert2Chain(data, signerIdx, FALSE, 0,
 818                  subject);
 819                 err = ERROR_SUCCESS;
 820             }
 821             CertFreeCertificateContext(subject);
 822         }
 823         else
 824             err = TRUST_E_NO_SIGNER_CERT;
 825         data->psPfns->pfnFree(certInfo);
 826     }
 827     else
 828         err = GetLastError();
 829     return err;
 830 }
 831
 832 static void load_secondary_signatures(CRYPT_PROVIDER_DATA *data, HCRYPTMSG msg)
 833 {
 834     CRYPT_PROVIDER_SIGSTATE *s = data->pSigState;
 835     CRYPT_ATTRIBUTES *attrs;
 836     unsigned int i, j;
 837     DWORD size;
 838
 839     if (!CryptMsgGetParam(msg, CMSG_SIGNER_UNAUTH_ATTR_PARAM, 0, NULL, &size))
 840         return;
 841
 842     if (!(attrs = data->psPfns->pfnAlloc(size)))
 843     {
 844         ERR("No memory.\n");
 845         return;
 846     }
 847     if (!CryptMsgGetParam(msg, CMSG_SIGNER_UNAUTH_ATTR_PARAM, 0, attrs, &size))
 848         goto done;
 849
 850     for (i = 0; i < attrs->cAttr; ++i)
 851     {
 852         if (strcmp(attrs->rgAttr[i].pszObjId, szOID_NESTED_SIGNATURE))
 853             continue;
 854
 855         if (!(s->rhSecondarySigs = data->psPfns->pfnAlloc(attrs->rgAttr[i].cValue * sizeof(*s->rhSecondarySigs))))
 856         {
 857             ERR("No memory.\n");
 858             goto done;
 859         }
 860         s->cSecondarySigs = 0;
 861         for (j = 0; j < attrs->rgAttr[i].cValue; ++j)
 862         {
 863             if (!(msg = CryptMsgOpenToDecode(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL)))
 864             {
 865                 ERR("Could not create crypt message.\n");
 866                 goto done;
 867             }
 868             if (!CryptMsgUpdate(msg, attrs->rgAttr[i].rgValue[j].pbData, attrs->rgAttr[i].rgValue[j].cbData, TRUE))
 869             {
 870                 ERR("Could not update crypt message, err %lu.\n", GetLastError());
 871                 CryptMsgClose(msg);
 872                 goto done;
 873             }
 874             s->rhSecondarySigs[j] = msg;
 875             ++s->cSecondarySigs;
 876         }
 877         break;
 878     }
 879 done:
 880     data->psPfns->pfnFree(attrs);
 881 }
 882
 883 HRESULT WINAPI SoftpubLoadSignature(CRYPT_PROVIDER_DATA *data)
 884 {
 885     DWORD err = ERROR_SUCCESS;
 886
 887     TRACE("(%p)\n", data);
 888
 889     if (!data->padwTrustStepErrors)
 890         return S_FALSE;
 891
 892     if (data->pSigState)
 893     {
 894         /* We did not initialize this, probably an unsupported usage. */
 895         FIXME("pSigState %p already initialized.\n", data->pSigState);
 896     }
 897     if (!(data->pSigState = data->psPfns->pfnAlloc(sizeof(*data->pSigState))))
 898     {
 899         err = ERROR_OUTOFMEMORY;
 900     }
 901     else
 902     {
 903         data->pSigState->cbStruct = sizeof(*data->pSigState);
 904         data->pSigState->fSupportMultiSig = TRUE;
 905         data->pSigState->dwCryptoPolicySupport = WSS_SIGTRUST_SUPPORT | WSS_OBJTRUST_SUPPORT | WSS_CERTTRUST_SUPPORT;
 906         if (data->hMsg)
 907         {
 908             data->pSigState->hPrimarySig = CryptMsgDuplicate(data->hMsg);
 909             load_secondary_signatures(data, data->pSigState->hPrimarySig);
 910         }
 911         if (data->pSigSettings)
 912         {
 913             if (data->pSigSettings->dwFlags & WSS_GET_SECONDARY_SIG_COUNT)
 914                 data->pSigSettings->cSecondarySigs = data->pSigState->cSecondarySigs;
 915         }
 916     }
 917
 918     if (!err && data->hMsg)
 919     {
 920         DWORD signerCount, size;
 921
 922         size = sizeof(signerCount);
 923         if (CryptMsgGetParam(data->hMsg, CMSG_SIGNER_COUNT_PARAM, 0,
 924          &signerCount, &size))
 925         {
 926             DWORD i;
 927
 928             err = ERROR_SUCCESS;
 929             for (i = 0; !err && i < signerCount; i++)
 930             {
 931                 if (!(err = WINTRUST_SaveSigner(data, i)))
 932                     err = WINTRUST_VerifySigner(data, i);
 933             }
 934         }
 935         else
 936             err = TRUST_E_NOSIGNATURE;
 937     }
 938
 939     if (err)
 940         data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_SIGPROV] = err;
 941     return !err ? S_OK : S_FALSE;
 942 }
 943
 944 static DWORD WINTRUST_TrustStatusToConfidence(DWORD errorStatus)
 945 {
 946     DWORD confidence = 0;
 947
 948     confidence = 0;
 949     if (!(errorStatus & CERT_TRUST_IS_NOT_SIGNATURE_VALID))
 950         confidence |= CERT_CONFIDENCE_SIG;
 951     if (!(errorStatus & CERT_TRUST_IS_NOT_TIME_VALID))
 952         confidence |= CERT_CONFIDENCE_TIME;
 953     if (!(errorStatus & CERT_TRUST_IS_NOT_TIME_NESTED))
 954         confidence |= CERT_CONFIDENCE_TIMENEST;
 955     return confidence;
 956 }
 957
 958 BOOL WINAPI SoftpubCheckCert(CRYPT_PROVIDER_DATA *data, DWORD idxSigner,
 959  BOOL fCounterSignerChain, DWORD idxCounterSigner)
 960 {
 961     BOOL ret;
 962
 963     TRACE("(%p, %ld, %d, %ld)\n", data, idxSigner, fCounterSignerChain,
 964      idxCounterSigner);
 965
 966     if (fCounterSignerChain)
 967     {
 968         FIXME("unimplemented for counter signers\n");
 969         ret = FALSE;
 970     }
 971     else
 972     {
 973         PCERT_SIMPLE_CHAIN simpleChain =
 974          data->pasSigners[idxSigner].pChainContext->rgpChain[0];
 975         DWORD i;
 976
 977         ret = TRUE;
 978         for (i = 0; i < simpleChain->cElement; i++)
 979         {
 980             /* Set confidence */
 981             data->pasSigners[idxSigner].pasCertChain[i].dwConfidence =
 982              WINTRUST_TrustStatusToConfidence(
 983              simpleChain->rgpElement[i]->TrustStatus.dwErrorStatus);
 984             /* Set additional flags */
 985             if (!(simpleChain->rgpElement[i]->TrustStatus.dwErrorStatus &
 986              CERT_TRUST_IS_UNTRUSTED_ROOT))
 987                 data->pasSigners[idxSigner].pasCertChain[i].fTrustedRoot = TRUE;
 988             if (simpleChain->rgpElement[i]->TrustStatus.dwInfoStatus &
 989              CERT_TRUST_IS_SELF_SIGNED)
 990                 data->pasSigners[idxSigner].pasCertChain[i].fSelfSigned = TRUE;
 991             if (simpleChain->rgpElement[i]->TrustStatus.dwErrorStatus &
 992              CERT_TRUST_IS_CYCLIC)
 993                 data->pasSigners[idxSigner].pasCertChain[i].fIsCyclic = TRUE;
 994         }
 995     }
 996     return ret;
 997 }
 998
 999 static DWORD WINTRUST_TrustStatusToError(DWORD errorStatus)
1000 {
1001     DWORD error;
1002
1003     if (errorStatus & CERT_TRUST_IS_NOT_SIGNATURE_VALID)
1004         error = TRUST_E_CERT_SIGNATURE;
1005     else if (errorStatus & CERT_TRUST_IS_UNTRUSTED_ROOT)
1006         error = CERT_E_UNTRUSTEDROOT;
1007     else if (errorStatus & CERT_TRUST_IS_NOT_TIME_VALID)
1008         error = CERT_E_EXPIRED;
1009     else if (errorStatus & CERT_TRUST_IS_NOT_TIME_NESTED)
1010         error = CERT_E_VALIDITYPERIODNESTING;
1011     else if (errorStatus & CERT_TRUST_IS_REVOKED)
1012         error = CERT_E_REVOKED;
1013     else if (errorStatus & CERT_TRUST_IS_OFFLINE_REVOCATION ||
1014      errorStatus & CERT_TRUST_REVOCATION_STATUS_UNKNOWN)
1015         error = CERT_E_REVOCATION_FAILURE;
1016     else if (errorStatus & CERT_TRUST_IS_NOT_VALID_FOR_USAGE)
1017         error = CERT_E_WRONG_USAGE;
1018     else if (errorStatus & CERT_TRUST_IS_CYCLIC)
1019         error = CERT_E_CHAINING;
1020     else if (errorStatus & CERT_TRUST_INVALID_EXTENSION)
1021         error = CERT_E_CRITICAL;
1022     else if (errorStatus & CERT_TRUST_INVALID_POLICY_CONSTRAINTS)
1023         error = CERT_E_INVALID_POLICY;
1024     else if (errorStatus & CERT_TRUST_INVALID_BASIC_CONSTRAINTS)
1025         error = TRUST_E_BASIC_CONSTRAINTS;
1026     else if (errorStatus & CERT_TRUST_INVALID_NAME_CONSTRAINTS ||
1027      errorStatus & CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT ||
1028      errorStatus & CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT ||
1029      errorStatus & CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT ||
1030      errorStatus & CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT)
1031         error = CERT_E_INVALID_NAME;
1032     else if (errorStatus & CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY)
1033         error = CERT_E_INVALID_POLICY;
1034     else if (errorStatus)
1035     {
1036         FIXME("unknown error status %08lx\n", errorStatus);
1037         error = TRUST_E_SYSTEM_ERROR;
1038     }
1039     else
1040         error = S_OK;
1041     return error;
1042 }
1043
1044 static DWORD WINTRUST_CopyChain(CRYPT_PROVIDER_DATA *data, DWORD signerIdx)
1045 {
1046     DWORD err, i;
1047     PCERT_SIMPLE_CHAIN simpleChain =
1048      data->pasSigners[signerIdx].pChainContext->rgpChain[0];
1049
1050     data->pasSigners[signerIdx].pasCertChain[0].dwConfidence =
1051      WINTRUST_TrustStatusToConfidence(
1052      simpleChain->rgpElement[0]->TrustStatus.dwErrorStatus);
1053     data->pasSigners[signerIdx].pasCertChain[0].pChainElement =
1054      simpleChain->rgpElement[0];
1055     err = ERROR_SUCCESS;
1056     for (i = 1; !err && i < simpleChain->cElement; i++)
1057     {
1058         if (data->psPfns->pfnAddCert2Chain(data, signerIdx, FALSE, 0,
1059          simpleChain->rgpElement[i]->pCertContext))
1060         {
1061             data->pasSigners[signerIdx].pasCertChain[i].pChainElement =
1062              simpleChain->rgpElement[i];
1063             data->pasSigners[signerIdx].pasCertChain[i].dwConfidence =
1064              WINTRUST_TrustStatusToConfidence(
1065              simpleChain->rgpElement[i]->TrustStatus.dwErrorStatus);
1066         }
1067         else
1068             err = GetLastError();
1069     }
1070     data->pasSigners[signerIdx].pasCertChain[simpleChain->cElement - 1].dwError
1071      = WINTRUST_TrustStatusToError(
1072      simpleChain->rgpElement[simpleChain->cElement - 1]->
1073      TrustStatus.dwErrorStatus);
1074     return err;
1075 }
1076
1077 static void WINTRUST_CreateChainPolicyCreateInfo(
1078  const CRYPT_PROVIDER_DATA *data, PWTD_GENERIC_CHAIN_POLICY_CREATE_INFO info,
1079  PCERT_CHAIN_PARA chainPara)
1080 {
1081     chainPara->cbSize = sizeof(CERT_CHAIN_PARA);
1082     if (data->pRequestUsage)
1083         chainPara->RequestedUsage = *data->pRequestUsage;
1084     else
1085     {
1086         chainPara->RequestedUsage.dwType = 0;
1087         chainPara->RequestedUsage.Usage.cUsageIdentifier = 0;
1088     }
1089     info->cbSize = sizeof(WTD_GENERIC_CHAIN_POLICY_CREATE_INFO);
1090     info->hChainEngine = NULL;
1091     info->pChainPara = chainPara;
1092     if (data->dwProvFlags & CPD_REVOCATION_CHECK_END_CERT)
1093         info->dwFlags = CERT_CHAIN_REVOCATION_CHECK_END_CERT;
1094     else if (data->dwProvFlags & CPD_REVOCATION_CHECK_CHAIN)
1095         info->dwFlags = CERT_CHAIN_REVOCATION_CHECK_CHAIN;
1096     else if (data->dwProvFlags & CPD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT)
1097         info->dwFlags = CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
1098     else
1099         info->dwFlags = 0;
1100     info->pvReserved = NULL;
1101 }
1102
1103 static DWORD WINTRUST_CreateChainForSigner(CRYPT_PROVIDER_DATA *data,
1104  DWORD signer, PWTD_GENERIC_CHAIN_POLICY_CREATE_INFO createInfo,
1105  PCERT_CHAIN_PARA chainPara)
1106 {
1107     DWORD err = ERROR_SUCCESS;
1108     HCERTSTORE store = NULL;
1109
1110     if (data->chStores)
1111     {
1112         store = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0,
1113          CERT_STORE_CREATE_NEW_FLAG, NULL);
1114         if (store)
1115         {
1116             DWORD i;
1117
1118             for (i = 0; i < data->chStores; i++)
1119                 CertAddStoreToCollection(store, data->pahStores[i], 0, 0);
1120         }
1121         else
1122             err = GetLastError();
1123     }
1124     if (!err)
1125     {
1126         /* Expect the end certificate for each signer to be the only cert in
1127          * the chain:
1128          */
1129         if (data->pasSigners[signer].csCertChain)
1130         {
1131             BOOL ret;
1132
1133             /* Create a certificate chain for each signer */
1134             ret = CertGetCertificateChain(createInfo->hChainEngine,
1135              data->pasSigners[signer].pasCertChain[0].pCert,
1136              &data->pasSigners[signer].sftVerifyAsOf, store,
1137              chainPara, createInfo->dwFlags, createInfo->pvReserved,
1138              &data->pasSigners[signer].pChainContext);
1139             if (ret)
1140             {
1141                 if (data->pasSigners[signer].pChainContext->cChain != 1)
1142                 {
1143                     FIXME("unimplemented for more than 1 simple chain\n");
1144                     err = E_NOTIMPL;
1145                 }
1146                 else
1147                 {
1148                     if (!(err = WINTRUST_CopyChain(data, signer)))
1149                     {
1150                         if (data->psPfns->pfnCertCheckPolicy)
1151                         {
1152                             ret = data->psPfns->pfnCertCheckPolicy(data, signer,
1153                              FALSE, 0);
1154                             if (!ret)
1155                                 err = GetLastError();
1156                         }
1157                         else
1158                             TRACE(
1159                              "no cert check policy, skipping policy check\n");
1160                     }
1161                 }
1162             }
1163             else
1164                 err = GetLastError();
1165         }
1166         CertCloseStore(store, 0);
1167     }
1168     return err;
1169 }
1170
1171 HRESULT WINAPI WintrustCertificateTrust(CRYPT_PROVIDER_DATA *data)
1172 {
1173     DWORD err;
1174
1175     TRACE("(%p)\n", data);
1176
1177     if (!data->csSigners)
1178         err = TRUST_E_NOSIGNATURE;
1179     else
1180     {
1181         DWORD i;
1182         WTD_GENERIC_CHAIN_POLICY_CREATE_INFO createInfo;
1183         CERT_CHAIN_PARA chainPara;
1184
1185         WINTRUST_CreateChainPolicyCreateInfo(data, &createInfo, &chainPara);
1186         err = ERROR_SUCCESS;
1187         for (i = 0; !err && i < data->csSigners; i++)
1188             err = WINTRUST_CreateChainForSigner(data, i, &createInfo,
1189              &chainPara);
1190     }
1191     if (err)
1192         data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV] = err;
1193     TRACE("returning %ld (%08lx)\n", !err ? S_OK : S_FALSE,
1194      data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV]);
1195     return !err ? S_OK : S_FALSE;
1196 }
1197
1198 HRESULT WINAPI GenericChainCertificateTrust(CRYPT_PROVIDER_DATA *data)
1199 {
1200     DWORD err;
1201     WTD_GENERIC_CHAIN_POLICY_DATA *policyData =
1202      data->pWintrustData->pPolicyCallbackData;
1203
1204     TRACE("(%p)\n", data);
1205
1206     if (policyData && policyData->cbSize !=
1207      sizeof(WTD_GENERIC_CHAIN_POLICY_CREATE_INFO))
1208     {
1209         err = ERROR_INVALID_PARAMETER;
1210         goto end;
1211     }
1212     if (!data->csSigners)
1213         err = TRUST_E_NOSIGNATURE;
1214     else
1215     {
1216         DWORD i;
1217         WTD_GENERIC_CHAIN_POLICY_CREATE_INFO createInfo, *pCreateInfo;
1218         CERT_CHAIN_PARA chainPara, *pChainPara;
1219
1220         if (policyData)
1221         {
1222             pCreateInfo = policyData->pSignerChainInfo;
1223             pChainPara = pCreateInfo->pChainPara;
1224         }
1225         else
1226         {
1227             WINTRUST_CreateChainPolicyCreateInfo(data, &createInfo, &chainPara);
1228             pChainPara = &chainPara;
1229             pCreateInfo = &createInfo;
1230         }
1231         err = ERROR_SUCCESS;
1232         for (i = 0; !err && i < data->csSigners; i++)
1233             err = WINTRUST_CreateChainForSigner(data, i, pCreateInfo,
1234              pChainPara);
1235     }
1236
1237 end:
1238     if (err)
1239         data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV] = err;
1240     TRACE("returning %ld (%08lx)\n", !err ? S_OK : S_FALSE,
1241      data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV]);
1242     return !err ? S_OK : S_FALSE;
1243 }
1244
1245 HRESULT WINAPI SoftpubAuthenticode(CRYPT_PROVIDER_DATA *data)
1246 {
1247     BOOL ret;
1248     CERT_CHAIN_POLICY_STATUS policyStatus = { sizeof(policyStatus), 0 };
1249
1250     TRACE("(%p)\n", data);
1251
1252     if (data->pWintrustData->dwUIChoice != WTD_UI_NONE)
1253         FIXME("unimplemented for UI choice %ld\n",
1254          data->pWintrustData->dwUIChoice);
1255     if (!data->csSigners)
1256     {
1257         ret = FALSE;
1258         policyStatus.dwError = TRUST_E_NOSIGNATURE;
1259     }
1260     else
1261     {
1262         DWORD i;
1263
1264         ret = TRUE;
1265         for (i = 0; ret && i < data->csSigners; i++)
1266         {
1267             BYTE hash[20];
1268             DWORD size = sizeof(hash);
1269
1270             /* First make sure cert isn't disallowed */
1271             if ((ret = CertGetCertificateContextProperty(
1272              data->pasSigners[i].pasCertChain[0].pCert,
1273              CERT_SIGNATURE_HASH_PROP_ID, hash, &size)))
1274             {
1275                 static const WCHAR disallowedW[] =
1276                  { 'D','i','s','a','l','l','o','w','e','d',0 };
1277                 HCERTSTORE disallowed = CertOpenStore(CERT_STORE_PROV_SYSTEM_W,
1278                  X509_ASN_ENCODING, 0, CERT_SYSTEM_STORE_CURRENT_USER,
1279                  disallowedW);
1280
1281                 if (disallowed)
1282                 {
1283                     PCCERT_CONTEXT found = CertFindCertificateInStore(
1284                      disallowed, X509_ASN_ENCODING, 0, CERT_FIND_SIGNATURE_HASH,
1285                      hash, NULL);
1286
1287                     if (found)
1288                     {
1289                         /* Disallowed!  Can't verify it. */
1290                         policyStatus.dwError = TRUST_E_SUBJECT_NOT_TRUSTED;
1291                         ret = FALSE;
1292                         CertFreeCertificateContext(found);
1293                     }
1294                     CertCloseStore(disallowed, 0);
1295                 }
1296             }
1297             if (ret)
1298             {
1299                 CERT_CHAIN_POLICY_PARA policyPara = { sizeof(policyPara), 0 };
1300
1301                 if (data->dwRegPolicySettings & WTPF_TRUSTTEST)
1302                     policyPara.dwFlags |= CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG;
1303                 if (data->dwRegPolicySettings & WTPF_TESTCANBEVALID)
1304                     policyPara.dwFlags |= CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG;
1305                 if (data->dwRegPolicySettings & WTPF_IGNOREEXPIRATION)
1306                     policyPara.dwFlags |=
1307                      CERT_CHAIN_POLICY_IGNORE_NOT_TIME_VALID_FLAG |
1308                      CERT_CHAIN_POLICY_IGNORE_CTL_NOT_TIME_VALID_FLAG |
1309                      CERT_CHAIN_POLICY_IGNORE_NOT_TIME_NESTED_FLAG;
1310                 if (data->dwRegPolicySettings & WTPF_IGNOREREVOKATION)
1311                     policyPara.dwFlags |=
1312                      CERT_CHAIN_POLICY_IGNORE_END_REV_UNKNOWN_FLAG |
1313                      CERT_CHAIN_POLICY_IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG |
1314                      CERT_CHAIN_POLICY_IGNORE_CA_REV_UNKNOWN_FLAG |
1315                      CERT_CHAIN_POLICY_IGNORE_ROOT_REV_UNKNOWN_FLAG;
1316                 CertVerifyCertificateChainPolicy(CERT_CHAIN_POLICY_AUTHENTICODE,
1317                  data->pasSigners[i].pChainContext, &policyPara, &policyStatus);
1318                 if (policyStatus.dwError != NO_ERROR)
1319                     ret = FALSE;
1320             }
1321         }
1322     }
1323     if (!ret)
1324         data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_POLICYPROV] =
1325          policyStatus.dwError;
1326     TRACE("returning %ld (%08lx)\n", ret ? S_OK : S_FALSE,
1327      data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_POLICYPROV]);
1328     return ret ? S_OK : S_FALSE;
1329 }
1330
1331 static HRESULT WINAPI WINTRUST_DefaultPolicy(CRYPT_PROVIDER_DATA *pProvData,
1332  DWORD dwStepError, DWORD dwRegPolicySettings, DWORD cSigner,
1333  PWTD_GENERIC_CHAIN_POLICY_SIGNER_INFO rgpSigner, void *pvPolicyArg)
1334 {
1335     DWORD i;
1336     CERT_CHAIN_POLICY_STATUS policyStatus = { sizeof(policyStatus), 0 };
1337
1338     for (i = 0; !policyStatus.dwError && i < cSigner; i++)
1339     {
1340         CERT_CHAIN_POLICY_PARA policyPara = { sizeof(policyPara), 0 };
1341
1342         if (dwRegPolicySettings & WTPF_IGNOREEXPIRATION)
1343             policyPara.dwFlags |=
1344              CERT_CHAIN_POLICY_IGNORE_NOT_TIME_VALID_FLAG |
1345              CERT_CHAIN_POLICY_IGNORE_CTL_NOT_TIME_VALID_FLAG |
1346              CERT_CHAIN_POLICY_IGNORE_NOT_TIME_NESTED_FLAG;
1347         if (dwRegPolicySettings & WTPF_IGNOREREVOKATION)
1348             policyPara.dwFlags |=
1349              CERT_CHAIN_POLICY_IGNORE_END_REV_UNKNOWN_FLAG |
1350              CERT_CHAIN_POLICY_IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG |
1351              CERT_CHAIN_POLICY_IGNORE_CA_REV_UNKNOWN_FLAG |
1352              CERT_CHAIN_POLICY_IGNORE_ROOT_REV_UNKNOWN_FLAG;
1353         CertVerifyCertificateChainPolicy(CERT_CHAIN_POLICY_BASE,
1354          rgpSigner[i].pChainContext, &policyPara, &policyStatus);
1355     }
1356     return policyStatus.dwError;
1357 }
1358
1359 HRESULT WINAPI GenericChainFinalProv(CRYPT_PROVIDER_DATA *data)
1360 {
1361     HRESULT err = NO_ERROR; /* not a typo, MS confused the types */
1362     WTD_GENERIC_CHAIN_POLICY_DATA *policyData =
1363      data->pWintrustData->pPolicyCallbackData;
1364
1365     TRACE("(%p)\n", data);
1366
1367     if (data->pWintrustData->dwUIChoice != WTD_UI_NONE)
1368         FIXME("unimplemented for UI choice %ld\n",
1369          data->pWintrustData->dwUIChoice);
1370     if (!data->csSigners)
1371         err = TRUST_E_NOSIGNATURE;
1372     else
1373     {
1374         PFN_WTD_GENERIC_CHAIN_POLICY_CALLBACK policyCallback;
1375         void *policyArg;
1376         WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO *signers = NULL;
1377
1378         if (policyData)
1379         {
1380             policyCallback = policyData->pfnPolicyCallback;
1381             policyArg = policyData->pvPolicyArg;
1382         }
1383         else
1384         {
1385             policyCallback = WINTRUST_DefaultPolicy;
1386             policyArg = NULL;
1387         }
1388         if (data->csSigners)
1389         {
1390             DWORD i;
1391
1392             signers = data->psPfns->pfnAlloc(
1393              data->csSigners * sizeof(WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO));
1394             if (signers)
1395             {
1396                 for (i = 0; i < data->csSigners; i++)
1397                 {
1398                     signers[i].cbSize =
1399                      sizeof(WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO);
1400                     signers[i].pChainContext =
1401                      data->pasSigners[i].pChainContext;
1402                     signers[i].dwSignerType = data->pasSigners[i].dwSignerType;
1403                     signers[i].pMsgSignerInfo = data->pasSigners[i].psSigner;
1404                     signers[i].dwError = data->pasSigners[i].dwError;
1405                     if (data->pasSigners[i].csCounterSigners)
1406                         FIXME("unimplemented for counter signers\n");
1407                     signers[i].cCounterSigner = 0;
1408                     signers[i].rgpCounterSigner = NULL;
1409                 }
1410             }
1411             else
1412                 err = ERROR_OUTOFMEMORY;
1413         }
1414         if (err == NO_ERROR)
1415             err = policyCallback(data, TRUSTERROR_STEP_FINAL_POLICYPROV,
1416              data->dwRegPolicySettings, data->csSigners, signers, policyArg);
1417         data->psPfns->pfnFree(signers);
1418     }
1419     if (err != NO_ERROR)
1420         data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_POLICYPROV] = err;
1421     TRACE("returning %ld (%08lx)\n", err == NO_ERROR ? S_OK : S_FALSE,
1422      data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_POLICYPROV]);
1423     return err == NO_ERROR ? S_OK : S_FALSE;
1424 }
1425
1426 HRESULT WINAPI SoftpubCleanup(CRYPT_PROVIDER_DATA *data)
1427 {
1428     DWORD i, j;
1429
1430     for (i = 0; i < data->csSigners; i++)
1431     {
1432         for (j = 0; j < data->pasSigners[i].csCertChain; j++)
1433             CertFreeCertificateContext(data->pasSigners[i].pasCertChain[j].pCert);
1434         data->psPfns->pfnFree(data->pasSigners[i].pasCertChain);
1435         data->psPfns->pfnFree(data->pasSigners[i].psSigner);
1436         CertFreeCertificateChain(data->pasSigners[i].pChainContext);
1437     }
1438     data->psPfns->pfnFree(data->pasSigners);
1439
1440     for (i = 0; i < data->chStores; i++)
1441         CertCloseStore(data->pahStores[i], 0);
1442     data->psPfns->pfnFree(data->pahStores);
1443
1444     if (data->pPDSip)
1445     {
1446         data->psPfns->pfnFree(data->pPDSip->pSip);
1447         data->psPfns->pfnFree(data->pPDSip->pCATSip);
1448         data->psPfns->pfnFree(data->pPDSip->psSipSubjectInfo);
1449         data->psPfns->pfnFree(data->pPDSip->psSipCATSubjectInfo);
1450         data->psPfns->pfnFree(data->pPDSip->psIndirectData);
1451     }
1452
1453     if (WVT_ISINSTRUCT(CRYPT_PROVIDER_DATA, data->cbStruct, pSigState) && data->pSigState)
1454     {
1455         CryptMsgClose(data->pSigState->hPrimarySig);
1456         for (i = 0; i < data->pSigState->cSecondarySigs; ++i)
1457             CryptMsgClose(data->pSigState->rhSecondarySigs[i]);
1458         data->psPfns->pfnFree(data->pSigState);
1459     }
1460     CryptMsgClose(data->hMsg);
1461
1462     if (data->fOpenedFile &&
1463      data->pWintrustData->dwUnionChoice == WTD_CHOICE_FILE &&
1464      data->pWintrustData->pFile)
1465     {
1466         CloseHandle(data->pWintrustData->pFile->hFile);
1467         data->pWintrustData->pFile->hFile = INVALID_HANDLE_VALUE;
1468         data->fOpenedFile = FALSE;
1469     }
1470
1471     return S_OK;
1472 }
1473
1474 HRESULT WINAPI HTTPSCertificateTrust(CRYPT_PROVIDER_DATA *data)
1475 {
1476     FIXME("(%p)\n", data);
1477     return S_OK;
1478 }
1479
1480 HRESULT WINAPI HTTPSFinalProv(CRYPT_PROVIDER_DATA *data)
1481 {
1482     FIXME("(%p)\n", data);
1483     return S_OK;
1484 }