ReactOS  0.4.15-dev-1033-gd7d716a
softpub.c
Go to the documentation of this file.
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 #include <stdarg.h>
20 
21 #define NONAMELESSUNION
22 
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winternl.h"
26 #include "wintrust.h"
27 #include "mssip.h"
28 #include "softpub.h"
29 #include "winnls.h"
30 #include "wine/debug.h"
31 
33 
35 {
37 
38  TRACE("(%p)\n", data);
39 
40  if (data->padwTrustStepErrors &&
41  !data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_WVTINIT])
42  ret = S_OK;
43  TRACE("returning %08x\n", ret);
44  return ret;
45 }
46 
48 {
50 
51  TRACE("(%p)\n", data);
52 
53  if (data->padwTrustStepErrors &&
54  !data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_WVTINIT])
55  ret = S_OK;
56  TRACE("returning %08x\n", ret);
57  return ret;
58 }
59 
61 {
62  FIXME("stub\n");
63  return S_OK;
64 }
65 
67 {
68  FIXME("stub\n");
69  return S_OK;
70 }
71 
73 {
74  FIXME("stub\n");
75  return S_OK;
76 }
77 
78 /* Assumes data->pWintrustData->u.pFile exists. Makes sure a file handle is
79  * open for the file.
80  */
82 {
84 
85  /* PSDK implies that all values should be initialized to NULL, so callers
86  * typically have hFile as NULL rather than INVALID_HANDLE_VALUE. Check
87  * for both.
88  */
89  if (!data->pWintrustData->u.pFile->hFile ||
90  data->pWintrustData->u.pFile->hFile == INVALID_HANDLE_VALUE)
91  {
92  data->pWintrustData->u.pFile->hFile =
93  CreateFileW(data->pWintrustData->u.pFile->pcwszFilePath, GENERIC_READ,
95  if (data->pWintrustData->u.pFile->hFile != INVALID_HANDLE_VALUE)
96  data->fOpenedFile = TRUE;
97  else
98  err = GetLastError();
99  }
100  if (!err)
101  GetFileTime(data->pWintrustData->u.pFile->hFile, &data->sftSystemTime,
102  NULL, NULL);
103  TRACE("returning %d\n", err);
104  return err;
105 }
106 
107 /* Assumes data->pWintrustData->u.pFile exists. Sets data->pPDSip->gSubject to
108  * the file's subject GUID.
109  */
111 {
113 
115  data->pWintrustData->u.pFile->cbStruct, pgKnownSubject) ||
116  !data->pWintrustData->u.pFile->pgKnownSubject)
117  {
119  data->pWintrustData->u.pFile->pcwszFilePath,
120  data->pWintrustData->u.pFile->hFile,
121  &data->u.pPDSip->gSubject))
122  {
124  DWORD sipError = GetLastError();
125 
126  /* Special case for empty files: the error is expected to be
127  * TRUST_E_SUBJECT_FORM_UNKNOWN, rather than whatever
128  * CryptSIPRetrieveSubjectGuid returns.
129  */
130  if (GetFileSizeEx(data->pWintrustData->u.pFile->hFile, &fileSize)
131  && !fileSize.QuadPart)
133  else
134  err = sipError;
135  }
136  }
137  else
138  data->u.pPDSip->gSubject = *data->pWintrustData->u.pFile->pgKnownSubject;
139  TRACE("returning %d\n", err);
140  return err;
141 }
142 
143 /* Assumes data->u.pPDSip exists, and its gSubject member set.
144  * Allocates data->u.pPDSip->pSip and loads it, if possible.
145  */
147 {
149 
150  data->u.pPDSip->pSip = data->psPfns->pfnAlloc(sizeof(SIP_DISPATCH_INFO));
151  if (data->u.pPDSip->pSip)
152  {
153  if (!CryptSIPLoad(&data->u.pPDSip->gSubject, 0, data->u.pPDSip->pSip))
154  err = GetLastError();
155  }
156  else
158  TRACE("returning %d\n", err);
159  return err;
160 }
161 
162 /* Assumes data->u.pPDSip has been loaded, and data->u.pPDSip->pSip allocated.
163  * Calls data->u.pPDSip->pSip->pfGet to construct data->hMsg.
164  */
166  LPCWSTR filePath)
167 {
169  BOOL ret;
170  LPBYTE buf = NULL;
171  DWORD size = 0;
172 
173  data->u.pPDSip->psSipSubjectInfo =
174  data->psPfns->pfnAlloc(sizeof(SIP_SUBJECTINFO));
175  if (!data->u.pPDSip->psSipSubjectInfo)
176  return ERROR_OUTOFMEMORY;
177 
178  data->u.pPDSip->psSipSubjectInfo->cbSize = sizeof(SIP_SUBJECTINFO);
179  data->u.pPDSip->psSipSubjectInfo->pgSubjectType = &data->u.pPDSip->gSubject;
180  data->u.pPDSip->psSipSubjectInfo->hFile = file;
181  data->u.pPDSip->psSipSubjectInfo->pwsFileName = filePath;
182  data->u.pPDSip->psSipSubjectInfo->hProv = data->hProv;
183  ret = data->u.pPDSip->pSip->pfGet(data->u.pPDSip->psSipSubjectInfo,
184  &data->dwEncoding, 0, &size, 0);
185  if (!ret)
186  return TRUST_E_NOSIGNATURE;
187 
188  buf = data->psPfns->pfnAlloc(size);
189  if (!buf)
190  return ERROR_OUTOFMEMORY;
191 
192  ret = data->u.pPDSip->pSip->pfGet(data->u.pPDSip->psSipSubjectInfo,
193  &data->dwEncoding, 0, &size, buf);
194  if (ret)
195  {
196  data->hMsg = CryptMsgOpenToDecode(data->dwEncoding, 0, 0, data->hProv,
197  NULL, NULL);
198  if (data->hMsg)
199  {
200  ret = CryptMsgUpdate(data->hMsg, buf, size, TRUE);
201  if (!ret)
202  err = GetLastError();
203  }
204  }
205  else
206  err = GetLastError();
207 
208  data->psPfns->pfnFree(buf);
209  TRACE("returning %d\n", err);
210  return err;
211 }
212 
214 {
215  DWORD bytes_read, size = end - start;
216  DWORD buffer_size = min( size, 1024*1024 );
218 
219  if (!buffer) return FALSE;
221  while (size)
222  {
223  if (!ReadFile( file, buffer, min( buffer_size, size ), &bytes_read, NULL )) break;
224  if (!bytes_read) break;
225  if (!CryptHashData( hash, buffer, bytes_read, 0 )) break;
226  size -= bytes_read;
227  }
228  HeapFree( GetProcessHeap(), 0, buffer );
229  return !size;
230 }
231 
232 /* See https://www.cs.auckland.ac.nz/~pgut001/pubs/authenticode.txt
233  * for details about the hashing.
234  */
236 {
237  DWORD checksum, security_dir;
239  union
240  {
241  IMAGE_NT_HEADERS32 nt32;
242  IMAGE_NT_HEADERS64 nt64;
243  } nt_header;
244  IMAGE_DATA_DIRECTORY secdir;
246  DWORD bytes_read;
247  BOOL ret;
248 
249  if (!GetFileSizeEx(file, &file_size))
250  return FALSE;
251 
253  ret = ReadFile(file, &dos_header, sizeof(dos_header), &bytes_read, NULL);
254  if (!ret || bytes_read != sizeof(dos_header))
255  return FALSE;
256 
258  return FALSE;
259  if (dos_header.e_lfanew >= 256 * 1024 * 1024) /* see RtlImageNtHeaderEx */
260  return FALSE;
261  if (dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader.MajorLinkerVersion) > file_size.QuadPart)
262  return FALSE;
263 
265  ret = ReadFile(file, &nt_header, sizeof(nt_header), &bytes_read, NULL);
266  if (!ret || bytes_read < FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader.Magic) +
267  sizeof(nt_header.nt32.OptionalHeader.Magic))
268  return FALSE;
269 
271  return FALSE;
272 
274  {
275  if (bytes_read < sizeof(nt_header.nt32))
276  return FALSE;
277 
278  checksum = dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader.CheckSum);
279  security_dir = dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]);
281  }
283  {
284  if (bytes_read < sizeof(nt_header.nt64))
285  return FALSE;
286 
287  checksum = dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS64, OptionalHeader.CheckSum);
288  security_dir = dos_header.e_lfanew + FIELD_OFFSET(IMAGE_NT_HEADERS64, OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]);
290  }
291  else
292  return FALSE;
293 
294  if (secdir.VirtualAddress < security_dir + sizeof(IMAGE_DATA_DIRECTORY))
295  return FALSE;
296  if (secdir.VirtualAddress > file_size.QuadPart)
297  return FALSE;
298  if (secdir.VirtualAddress + secdir.Size != file_size.QuadPart)
299  return FALSE;
300 
301  if (!hash_file_data( file, 0, checksum, hash )) return FALSE;
302  if (!hash_file_data( file, checksum + sizeof(DWORD), security_dir, hash )) return FALSE;
303  if (!hash_file_data( file, security_dir + sizeof(IMAGE_DATA_DIRECTORY), secdir.VirtualAddress, hash ))
304  return FALSE;
305 
306  return TRUE;
307 }
308 
310 {
311  SPC_INDIRECT_DATA_CONTENT *indirect = (SPC_INDIRECT_DATA_CONTENT *)data->u.pPDSip->psIndirectData;
312  DWORD err, hash_size, length;
313  BYTE *hash_data;
314  BOOL release_prov = FALSE;
315  HCRYPTPROV prov = data->hProv;
316  HCRYPTHASH hash = 0;
317  ALG_ID algID;
318 
319  if (((ULONG_PTR)indirect->Data.pszObjId >> 16) == 0 ||
320  strcmp(indirect->Data.pszObjId, SPC_PE_IMAGE_DATA_OBJID))
321  {
322  FIXME("Cannot verify hash for pszObjId=%s\n", debugstr_a(indirect->Data.pszObjId));
323  return ERROR_SUCCESS;
324  }
325 
326  if (!(algID = CertOIDToAlgId(indirect->DigestAlgorithm.pszObjId)))
327  return TRUST_E_SYSTEM_ERROR; /* FIXME */
328 
329  if (!prov)
330  {
332  return GetLastError();
333  release_prov = TRUE;
334  }
335 
336  if (!CryptCreateHash(prov, algID, 0, 0, &hash))
337  {
338  err = GetLastError();
339  goto done;
340  }
341 
343  {
345  goto done;
346  }
347 
348  length = sizeof(hash_size);
349  if (!CryptGetHashParam(hash, HP_HASHSIZE, (BYTE *)&hash_size, &length, 0))
350  {
351  err = GetLastError();
352  goto done;
353  }
354 
355  if (!(hash_data = data->psPfns->pfnAlloc(hash_size)))
356  {
358  goto done;
359  }
360 
361  if (!CryptGetHashParam(hash, HP_HASHVAL, hash_data, &hash_size, 0))
362  {
363  err = GetLastError();
364  data->psPfns->pfnFree(hash_data);
365  goto done;
366  }
367 
368  err = (hash_size == indirect->Digest.cbData &&
369  !memcmp(hash_data, indirect->Digest.pbData, hash_size)) ? S_OK : TRUST_E_BAD_DIGEST;
370  data->psPfns->pfnFree(hash_data);
371 
372 done:
373  if (hash)
375  if (release_prov)
376  CryptReleaseContext(prov, 0);
377  return err;
378 }
379 
380 
382 {
384  HCERTSTORE store;
385 
386  store = CertOpenStore(CERT_STORE_PROV_MSG, data->dwEncoding,
388  if (store)
389  {
390  if (!data->psPfns->pfnAddStore2Chain(data, store))
391  err = GetLastError();
392  CertCloseStore(store, 0);
393  }
394  else
395  err = GetLastError();
396  TRACE("returning %d\n", err);
397  return err;
398 }
399 
401 {
402  BOOL ret;
404  LPSTR oid = NULL;
405  LPBYTE buf = NULL;
406 
408  &size);
409  if (!ret)
410  {
411  err = GetLastError();
412  goto error;
413  }
414  oid = data->psPfns->pfnAlloc(size);
415  if (!oid)
416  {
418  goto error;
419  }
421  &size);
422  if (!ret)
423  {
424  err = GetLastError();
425  goto error;
426  }
428  if (!ret)
429  {
430  err = GetLastError();
431  goto error;
432  }
433  buf = data->psPfns->pfnAlloc(size);
434  if (!buf)
435  {
437  goto error;
438  }
440  if (!ret)
441  {
442  err = GetLastError();
443  goto error;
444  }
445  ret = CryptDecodeObject(data->dwEncoding, oid, buf, size, 0, NULL, &size);
446  if (!ret)
447  {
448  err = GetLastError();
449  goto error;
450  }
451  data->u.pPDSip->psIndirectData = data->psPfns->pfnAlloc(size);
452  if (!data->u.pPDSip->psIndirectData)
453  {
455  goto error;
456  }
457  ret = CryptDecodeObject(data->dwEncoding, oid, buf, size, 0,
458  data->u.pPDSip->psIndirectData, &size);
459  if (!ret)
460  err = GetLastError();
461 
462 error:
463  TRACE("returning %d\n", err);
464  data->psPfns->pfnFree(oid);
465  data->psPfns->pfnFree(buf);
466  return err;
467 }
468 
470 {
472 
473  if (data->pWintrustData->u.pCert &&
475  data->pWintrustData->u.pCert->cbStruct, psCertContext))
476  {
477  if (data->psPfns)
478  {
479  CRYPT_PROVIDER_SGNR signer = { sizeof(signer), { 0 } };
480  DWORD i;
481  BOOL ret;
482 
483  /* Add a signer with nothing but the time to verify, so we can
484  * add a cert to it
485  */
487  data->pWintrustData->u.pCert->cbStruct, psftVerifyAsOf) &&
488  data->pWintrustData->u.pCert->psftVerifyAsOf)
489  data->sftSystemTime = signer.sftVerifyAsOf;
490  else
491  {
492  SYSTEMTIME sysTime;
493 
494  GetSystemTime(&sysTime);
495  SystemTimeToFileTime(&sysTime, &signer.sftVerifyAsOf);
496  }
497  ret = data->psPfns->pfnAddSgnr2Chain(data, FALSE, 0, &signer);
498  if (ret)
499  {
500  ret = data->psPfns->pfnAddCert2Chain(data, 0, FALSE, 0,
501  data->pWintrustData->u.pCert->psCertContext);
503  data->pWintrustData->u.pCert->cbStruct, pahStores))
504  for (i = 0;
505  ret && i < data->pWintrustData->u.pCert->chStores; i++)
506  ret = data->psPfns->pfnAddStore2Chain(data,
507  data->pWintrustData->u.pCert->pahStores[i]);
508  }
509  if (!ret)
510  err = GetLastError();
511  }
512  }
513  else
515  return err;
516 }
517 
519 {
521 
522  if (!data->pWintrustData->u.pFile)
523  {
525  goto error;
526  }
528  if (err)
529  goto error;
531  if (err)
532  goto error;
534  if (err)
535  goto error;
536  err = SOFTPUB_GetMessageFromFile(data, data->pWintrustData->u.pFile->hFile,
537  data->pWintrustData->u.pFile->pcwszFilePath);
538  if (err)
539  goto error;
541  if (err)
542  goto error;
544  if (err)
545  goto error;
546  err = SOFTPUB_VerifyImageHash(data, data->pWintrustData->u.pFile->hFile);
547 
548 error:
549  if (err && data->fOpenedFile && data->pWintrustData->u.pFile)
550  {
551  /* The caller won't expect the file to be open on failure, so close it.
552  */
553  CloseHandle(data->pWintrustData->u.pFile->hFile);
554  data->pWintrustData->u.pFile->hFile = INVALID_HANDLE_VALUE;
555  data->fOpenedFile = FALSE;
556  }
557  return err;
558 }
559 
561 {
562  DWORD err;
563  HANDLE catalog = INVALID_HANDLE_VALUE;
564 
565  if (!data->pWintrustData->u.pCatalog)
566  {
568  return FALSE;
569  }
570  catalog = CreateFileW(data->pWintrustData->u.pCatalog->pcwszCatalogFilePath,
572  NULL);
573  if (catalog == INVALID_HANDLE_VALUE)
574  return GetLastError();
576  data->pWintrustData->u.pCatalog->pcwszCatalogFilePath, catalog,
577  &data->u.pPDSip->gSubject))
578  {
579  err = GetLastError();
580  goto error;
581  }
583  if (err)
584  goto error;
586  data->pWintrustData->u.pCatalog->pcwszCatalogFilePath);
587  if (err)
588  goto error;
590  if (err)
591  goto error;
593  /* FIXME: this loads the catalog file, but doesn't validate the member. */
594 error:
595  CloseHandle(catalog);
596  return err;
597 }
598 
600 {
602 
603  TRACE("(%p)\n", data);
604 
605  if (!data->padwTrustStepErrors)
606  return S_FALSE;
607 
608  switch (data->pWintrustData->dwUnionChoice)
609  {
610  case WTD_CHOICE_CERT:
612  break;
613  case WTD_CHOICE_FILE:
615  break;
616  case WTD_CHOICE_CATALOG:
618  break;
619  default:
620  FIXME("unimplemented for %d\n", data->pWintrustData->dwUnionChoice);
622  }
623 
624  if (err)
625  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] = err;
626  TRACE("returning %d (%08x)\n", !err ? S_OK : S_FALSE,
627  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV]);
628  return !err ? S_OK : S_FALSE;
629 }
630 
632  DWORD signerIdx)
633 {
634  BOOL ret;
635  CMSG_SIGNER_INFO *signerInfo = NULL;
636  DWORD size;
637 
638  ret = CryptMsgGetParam(data->hMsg, CMSG_SIGNER_INFO_PARAM, signerIdx,
639  NULL, &size);
640  if (ret)
641  {
642  signerInfo = data->psPfns->pfnAlloc(size);
643  if (signerInfo)
644  {
646  signerIdx, signerInfo, &size);
647  if (!ret)
648  {
649  data->psPfns->pfnFree(signerInfo);
650  signerInfo = NULL;
651  }
652  }
653  else
655  }
656  return signerInfo;
657 }
658 
660  const CMSG_CMS_SIGNER_INFO *counterSignerInfo, FILETIME *time)
661 {
662  DWORD i;
663  BOOL foundTimeStamp = FALSE;
664 
665  for (i = 0; !foundTimeStamp && i < counterSignerInfo->AuthAttrs.cAttr; i++)
666  {
667  if (!strcmp(counterSignerInfo->AuthAttrs.rgAttr[i].pszObjId,
669  {
670  const CRYPT_ATTRIBUTE *attr =
671  &counterSignerInfo->AuthAttrs.rgAttr[i];
672  DWORD j;
673 
674  for (j = 0; !foundTimeStamp && j < attr->cValue; j++)
675  {
676  static const DWORD encoding = X509_ASN_ENCODING |
678  DWORD size = sizeof(FILETIME);
679 
680  foundTimeStamp = CryptDecodeObjectEx(encoding,
682  attr->rgValue[j].pbData, attr->rgValue[j].cbData, 0, NULL,
683  time, &size);
684  }
685  }
686  }
687  return foundTimeStamp;
688 }
689 
691 {
692  static char date[80];
693  char dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
694  SYSTEMTIME sysTime;
695 
696  if (!time) return NULL;
697 
699  FileTimeToSystemTime(time, &sysTime);
700  GetDateFormatA(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date, ARRAY_SIZE(date));
701  return date;
702 }
703 
705  const CMSG_SIGNER_INFO *signerInfo)
706 {
707  DWORD i;
708  FILETIME time;
709  BOOL foundTimeStamp = FALSE;
710 
711  for (i = 0; !foundTimeStamp && i < signerInfo->UnauthAttrs.cAttr; i++)
712  {
713  if (!strcmp(signerInfo->UnauthAttrs.rgAttr[i].pszObjId,
715  {
716  const CRYPT_ATTRIBUTE *attr = &signerInfo->UnauthAttrs.rgAttr[i];
717  DWORD j;
718 
719  for (j = 0; j < attr->cValue; j++)
720  {
721  static const DWORD encoding = X509_ASN_ENCODING |
723  CMSG_CMS_SIGNER_INFO *counterSignerInfo;
724  DWORD size;
726  attr->rgValue[j].pbData, attr->rgValue[j].cbData,
727  CRYPT_DECODE_ALLOC_FLAG, NULL, &counterSignerInfo, &size);
728  if (ret)
729  {
730  /* FIXME: need to verify countersigner signature too */
731  foundTimeStamp = WINTRUST_GetTimeFromCounterSigner(
732  counterSignerInfo, &time);
733  LocalFree(counterSignerInfo);
734  }
735  }
736  }
737  }
738  if (!foundTimeStamp)
739  {
740  TRACE("returning system time %s\n",
741  filetime_to_str(&data->sftSystemTime));
742  time = data->sftSystemTime;
743  }
744  else
745  TRACE("returning time from message %s\n", filetime_to_str(&time));
746  return time;
747 }
748 
750 {
751  DWORD err;
752  CMSG_SIGNER_INFO *signerInfo = WINTRUST_GetSigner(data, signerIdx);
753 
754  if (signerInfo)
755  {
756  CRYPT_PROVIDER_SGNR sgnr = { sizeof(sgnr), { 0 } };
757 
758  sgnr.psSigner = signerInfo;
759  sgnr.sftVerifyAsOf = WINTRUST_GetTimeFromSigner(data, signerInfo);
760  if (!data->psPfns->pfnAddSgnr2Chain(data, FALSE, signerIdx, &sgnr))
761  err = GetLastError();
762  else
763  err = ERROR_SUCCESS;
764  }
765  else
766  err = GetLastError();
767  return err;
768 }
769 
771  DWORD signerIdx)
772 {
773  BOOL ret;
774  CERT_INFO *certInfo = NULL;
775  DWORD size;
776 
778  NULL, &size);
779  if (ret)
780  {
781  certInfo = data->psPfns->pfnAlloc(size);
782  if (certInfo)
783  {
785  signerIdx, certInfo, &size);
786  if (!ret)
787  {
788  data->psPfns->pfnFree(certInfo);
789  certInfo = NULL;
790  }
791  }
792  else
794  }
795  return certInfo;
796 }
797 
799 {
800  DWORD err;
801  CERT_INFO *certInfo = WINTRUST_GetSignerCertInfo(data, signerIdx);
802 
803  if (certInfo)
804  {
806  data->pahStores[0], data->dwEncoding, certInfo);
807 
808  if (subject)
809  {
810  CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA para = { sizeof(para), 0,
811  signerIdx, CMSG_VERIFY_SIGNER_CERT, (LPVOID)subject };
812 
814  &para))
816  else
817  {
818  data->psPfns->pfnAddCert2Chain(data, signerIdx, FALSE, 0,
819  subject);
820  err = ERROR_SUCCESS;
821  }
823  }
824  else
826  data->psPfns->pfnFree(certInfo);
827  }
828  else
829  err = GetLastError();
830  return err;
831 }
832 
834 {
835  DWORD err;
836 
837  TRACE("(%p)\n", data);
838 
839  if (!data->padwTrustStepErrors)
840  return S_FALSE;
841 
842  if (data->hMsg)
843  {
844  DWORD signerCount, size;
845 
846  size = sizeof(signerCount);
848  &signerCount, &size))
849  {
850  DWORD i;
851 
852  err = ERROR_SUCCESS;
853  for (i = 0; !err && i < signerCount; i++)
854  {
855  if (!(err = WINTRUST_SaveSigner(data, i)))
857  }
858  }
859  else
861  }
862  else
863  err = ERROR_SUCCESS;
864  if (err)
865  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_SIGPROV] = err;
866  return !err ? S_OK : S_FALSE;
867 }
868 
870 {
871  DWORD confidence = 0;
872 
873  confidence = 0;
874  if (!(errorStatus & CERT_TRUST_IS_NOT_SIGNATURE_VALID))
875  confidence |= CERT_CONFIDENCE_SIG;
876  if (!(errorStatus & CERT_TRUST_IS_NOT_TIME_VALID))
877  confidence |= CERT_CONFIDENCE_TIME;
878  if (!(errorStatus & CERT_TRUST_IS_NOT_TIME_NESTED))
879  confidence |= CERT_CONFIDENCE_TIMENEST;
880  return confidence;
881 }
882 
884  BOOL fCounterSignerChain, DWORD idxCounterSigner)
885 {
886  BOOL ret;
887 
888  TRACE("(%p, %d, %d, %d)\n", data, idxSigner, fCounterSignerChain,
889  idxCounterSigner);
890 
891  if (fCounterSignerChain)
892  {
893  FIXME("unimplemented for counter signers\n");
894  ret = FALSE;
895  }
896  else
897  {
898  PCERT_SIMPLE_CHAIN simpleChain =
899  data->pasSigners[idxSigner].pChainContext->rgpChain[0];
900  DWORD i;
901 
902  ret = TRUE;
903  for (i = 0; i < simpleChain->cElement; i++)
904  {
905  /* Set confidence */
906  data->pasSigners[idxSigner].pasCertChain[i].dwConfidence =
908  simpleChain->rgpElement[i]->TrustStatus.dwErrorStatus);
909  /* Set additional flags */
910  if (!(simpleChain->rgpElement[i]->TrustStatus.dwErrorStatus &
912  data->pasSigners[idxSigner].pasCertChain[i].fTrustedRoot = TRUE;
913  if (simpleChain->rgpElement[i]->TrustStatus.dwInfoStatus &
915  data->pasSigners[idxSigner].pasCertChain[i].fSelfSigned = TRUE;
916  if (simpleChain->rgpElement[i]->TrustStatus.dwErrorStatus &
918  data->pasSigners[idxSigner].pasCertChain[i].fIsCyclic = TRUE;
919  }
920  }
921  return ret;
922 }
923 
925 {
926  DWORD error;
927 
928  if (errorStatus & CERT_TRUST_IS_NOT_SIGNATURE_VALID)
930  else if (errorStatus & CERT_TRUST_IS_UNTRUSTED_ROOT)
932  else if (errorStatus & CERT_TRUST_IS_NOT_TIME_VALID)
934  else if (errorStatus & CERT_TRUST_IS_NOT_TIME_NESTED)
936  else if (errorStatus & CERT_TRUST_IS_REVOKED)
938  else if (errorStatus & CERT_TRUST_IS_OFFLINE_REVOCATION ||
941  else if (errorStatus & CERT_TRUST_IS_NOT_VALID_FOR_USAGE)
943  else if (errorStatus & CERT_TRUST_IS_CYCLIC)
945  else if (errorStatus & CERT_TRUST_INVALID_EXTENSION)
947  else if (errorStatus & CERT_TRUST_INVALID_POLICY_CONSTRAINTS)
949  else if (errorStatus & CERT_TRUST_INVALID_BASIC_CONSTRAINTS)
951  else if (errorStatus & CERT_TRUST_INVALID_NAME_CONSTRAINTS ||
957  else if (errorStatus & CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY)
959  else if (errorStatus)
960  {
961  FIXME("unknown error status %08x\n", errorStatus);
963  }
964  else
965  error = S_OK;
966  return error;
967 }
968 
970 {
971  DWORD err, i;
972  PCERT_SIMPLE_CHAIN simpleChain =
973  data->pasSigners[signerIdx].pChainContext->rgpChain[0];
974 
975  data->pasSigners[signerIdx].pasCertChain[0].dwConfidence =
977  simpleChain->rgpElement[0]->TrustStatus.dwErrorStatus);
978  data->pasSigners[signerIdx].pasCertChain[0].pChainElement =
979  simpleChain->rgpElement[0];
980  err = ERROR_SUCCESS;
981  for (i = 1; !err && i < simpleChain->cElement; i++)
982  {
983  if (data->psPfns->pfnAddCert2Chain(data, signerIdx, FALSE, 0,
984  simpleChain->rgpElement[i]->pCertContext))
985  {
986  data->pasSigners[signerIdx].pasCertChain[i].pChainElement =
987  simpleChain->rgpElement[i];
988  data->pasSigners[signerIdx].pasCertChain[i].dwConfidence =
990  simpleChain->rgpElement[i]->TrustStatus.dwErrorStatus);
991  }
992  else
993  err = GetLastError();
994  }
995  data->pasSigners[signerIdx].pasCertChain[simpleChain->cElement - 1].dwError
997  simpleChain->rgpElement[simpleChain->cElement - 1]->
998  TrustStatus.dwErrorStatus);
999  return err;
1000 }
1001 
1004  PCERT_CHAIN_PARA chainPara)
1005 {
1006  chainPara->cbSize = sizeof(CERT_CHAIN_PARA);
1007  if (data->pRequestUsage)
1008  chainPara->RequestedUsage = *data->pRequestUsage;
1009  else
1010  {
1011  chainPara->RequestedUsage.dwType = 0;
1012  chainPara->RequestedUsage.Usage.cUsageIdentifier = 0;
1013  }
1014  info->u.cbSize = sizeof(WTD_GENERIC_CHAIN_POLICY_CREATE_INFO);
1015  info->hChainEngine = NULL;
1016  info->pChainPara = chainPara;
1017  if (data->dwProvFlags & CPD_REVOCATION_CHECK_END_CERT)
1019  else if (data->dwProvFlags & CPD_REVOCATION_CHECK_CHAIN)
1021  else if (data->dwProvFlags & CPD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT)
1023  else
1024  info->dwFlags = 0;
1025  info->pvReserved = NULL;
1026 }
1027 
1029  DWORD signer, PWTD_GENERIC_CHAIN_POLICY_CREATE_INFO createInfo,
1030  PCERT_CHAIN_PARA chainPara)
1031 {
1033  HCERTSTORE store = NULL;
1034 
1035  if (data->chStores)
1036  {
1039  if (store)
1040  {
1041  DWORD i;
1042 
1043  for (i = 0; i < data->chStores; i++)
1044  CertAddStoreToCollection(store, data->pahStores[i], 0, 0);
1045  }
1046  else
1047  err = GetLastError();
1048  }
1049  if (!err)
1050  {
1051  /* Expect the end certificate for each signer to be the only cert in
1052  * the chain:
1053  */
1054  if (data->pasSigners[signer].csCertChain)
1055  {
1056  BOOL ret;
1057 
1058  /* Create a certificate chain for each signer */
1060  data->pasSigners[signer].pasCertChain[0].pCert,
1061  &data->pasSigners[signer].sftVerifyAsOf, store,
1062  chainPara, createInfo->dwFlags, createInfo->pvReserved,
1063  &data->pasSigners[signer].pChainContext);
1064  if (ret)
1065  {
1066  if (data->pasSigners[signer].pChainContext->cChain != 1)
1067  {
1068  FIXME("unimplemented for more than 1 simple chain\n");
1069  err = E_NOTIMPL;
1070  }
1071  else
1072  {
1073  if (!(err = WINTRUST_CopyChain(data, signer)))
1074  {
1075  if (data->psPfns->pfnCertCheckPolicy)
1076  {
1077  ret = data->psPfns->pfnCertCheckPolicy(data, signer,
1078  FALSE, 0);
1079  if (!ret)
1080  err = GetLastError();
1081  }
1082  else
1083  TRACE(
1084  "no cert check policy, skipping policy check\n");
1085  }
1086  }
1087  }
1088  else
1089  err = GetLastError();
1090  }
1091  CertCloseStore(store, 0);
1092  }
1093  return err;
1094 }
1095 
1097 {
1098  DWORD err;
1099 
1100  TRACE("(%p)\n", data);
1101 
1102  if (!data->csSigners)
1104  else
1105  {
1106  DWORD i;
1108  CERT_CHAIN_PARA chainPara;
1109 
1110  WINTRUST_CreateChainPolicyCreateInfo(data, &createInfo, &chainPara);
1111  err = ERROR_SUCCESS;
1112  for (i = 0; !err && i < data->csSigners; i++)
1113  err = WINTRUST_CreateChainForSigner(data, i, &createInfo,
1114  &chainPara);
1115  }
1116  if (err)
1117  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV] = err;
1118  TRACE("returning %d (%08x)\n", !err ? S_OK : S_FALSE,
1119  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV]);
1120  return !err ? S_OK : S_FALSE;
1121 }
1122 
1124 {
1125  DWORD err;
1126  WTD_GENERIC_CHAIN_POLICY_DATA *policyData =
1127  data->pWintrustData->pPolicyCallbackData;
1128 
1129  TRACE("(%p)\n", data);
1130 
1131  if (policyData && policyData->u.cbSize !=
1133  {
1135  goto end;
1136  }
1137  if (!data->csSigners)
1139  else
1140  {
1141  DWORD i;
1142  WTD_GENERIC_CHAIN_POLICY_CREATE_INFO createInfo, *pCreateInfo;
1143  CERT_CHAIN_PARA chainPara, *pChainPara;
1144 
1145  if (policyData)
1146  {
1147  pCreateInfo = policyData->pSignerChainInfo;
1148  pChainPara = pCreateInfo->pChainPara;
1149  }
1150  else
1151  {
1152  WINTRUST_CreateChainPolicyCreateInfo(data, &createInfo, &chainPara);
1153  pChainPara = &chainPara;
1154  pCreateInfo = &createInfo;
1155  }
1156  err = ERROR_SUCCESS;
1157  for (i = 0; !err && i < data->csSigners; i++)
1158  err = WINTRUST_CreateChainForSigner(data, i, pCreateInfo,
1159  pChainPara);
1160  }
1161 
1162 end:
1163  if (err)
1164  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV] = err;
1165  TRACE("returning %d (%08x)\n", !err ? S_OK : S_FALSE,
1166  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV]);
1167  return !err ? S_OK : S_FALSE;
1168 }
1169 
1171 {
1172  BOOL ret;
1173  CERT_CHAIN_POLICY_STATUS policyStatus = { sizeof(policyStatus), 0 };
1174 
1175  TRACE("(%p)\n", data);
1176 
1177  if (data->pWintrustData->dwUIChoice != WTD_UI_NONE)
1178  FIXME("unimplemented for UI choice %d\n",
1179  data->pWintrustData->dwUIChoice);
1180  if (!data->csSigners)
1181  {
1182  ret = FALSE;
1183  policyStatus.dwError = TRUST_E_NOSIGNATURE;
1184  }
1185  else
1186  {
1187  DWORD i;
1188 
1189  ret = TRUE;
1190  for (i = 0; ret && i < data->csSigners; i++)
1191  {
1192  BYTE hash[20];
1193  DWORD size = sizeof(hash);
1194 
1195  /* First make sure cert isn't disallowed */
1197  data->pasSigners[i].pasCertChain[0].pCert,
1199  {
1200  static const WCHAR disallowedW[] =
1201  { 'D','i','s','a','l','l','o','w','e','d',0 };
1204  disallowedW);
1205 
1206  if (disallowed)
1207  {
1210  hash, NULL);
1211 
1212  if (found)
1213  {
1214  /* Disallowed! Can't verify it. */
1215  policyStatus.dwError = TRUST_E_SUBJECT_NOT_TRUSTED;
1216  ret = FALSE;
1218  }
1220  }
1221  }
1222  if (ret)
1223  {
1224  CERT_CHAIN_POLICY_PARA policyPara = { sizeof(policyPara), 0 };
1225 
1226  if (data->dwRegPolicySettings & WTPF_TRUSTTEST)
1228  if (data->dwRegPolicySettings & WTPF_TESTCANBEVALID)
1230  if (data->dwRegPolicySettings & WTPF_IGNOREEXPIRATION)
1231  policyPara.dwFlags |=
1235  if (data->dwRegPolicySettings & WTPF_IGNOREREVOKATION)
1236  policyPara.dwFlags |=
1242  data->pasSigners[i].pChainContext, &policyPara, &policyStatus);
1243  if (policyStatus.dwError != NO_ERROR)
1244  ret = FALSE;
1245  }
1246  }
1247  }
1248  if (!ret)
1249  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_POLICYPROV] =
1250  policyStatus.dwError;
1251  TRACE("returning %d (%08x)\n", ret ? S_OK : S_FALSE,
1252  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_POLICYPROV]);
1253  return ret ? S_OK : S_FALSE;
1254 }
1255 
1257  DWORD dwStepError, DWORD dwRegPolicySettings, DWORD cSigner,
1258  PWTD_GENERIC_CHAIN_POLICY_SIGNER_INFO rgpSigner, void *pvPolicyArg)
1259 {
1260  DWORD i;
1261  CERT_CHAIN_POLICY_STATUS policyStatus = { sizeof(policyStatus), 0 };
1262 
1263  for (i = 0; !policyStatus.dwError && i < cSigner; i++)
1264  {
1265  CERT_CHAIN_POLICY_PARA policyPara = { sizeof(policyPara), 0 };
1266 
1267  if (dwRegPolicySettings & WTPF_IGNOREEXPIRATION)
1268  policyPara.dwFlags |=
1272  if (dwRegPolicySettings & WTPF_IGNOREREVOKATION)
1273  policyPara.dwFlags |=
1279  rgpSigner[i].pChainContext, &policyPara, &policyStatus);
1280  }
1281  return policyStatus.dwError;
1282 }
1283 
1285 {
1286  HRESULT err = NO_ERROR; /* not a typo, MS confused the types */
1287  WTD_GENERIC_CHAIN_POLICY_DATA *policyData =
1288  data->pWintrustData->pPolicyCallbackData;
1289 
1290  TRACE("(%p)\n", data);
1291 
1292  if (data->pWintrustData->dwUIChoice != WTD_UI_NONE)
1293  FIXME("unimplemented for UI choice %d\n",
1294  data->pWintrustData->dwUIChoice);
1295  if (!data->csSigners)
1297  else
1298  {
1300  void *policyArg;
1302 
1303  if (policyData)
1304  {
1305  policyCallback = policyData->pfnPolicyCallback;
1306  policyArg = policyData->pvPolicyArg;
1307  }
1308  else
1309  {
1310  policyCallback = WINTRUST_DefaultPolicy;
1311  policyArg = NULL;
1312  }
1313  if (data->csSigners)
1314  {
1315  DWORD i;
1316 
1317  signers = data->psPfns->pfnAlloc(
1318  data->csSigners * sizeof(WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO));
1319  if (signers)
1320  {
1321  for (i = 0; i < data->csSigners; i++)
1322  {
1323  signers[i].u.cbSize =
1325  signers[i].pChainContext =
1326  data->pasSigners[i].pChainContext;
1327  signers[i].dwSignerType = data->pasSigners[i].dwSignerType;
1328  signers[i].pMsgSignerInfo = data->pasSigners[i].psSigner;
1329  signers[i].dwError = data->pasSigners[i].dwError;
1330  if (data->pasSigners[i].csCounterSigners)
1331  FIXME("unimplemented for counter signers\n");
1332  signers[i].cCounterSigner = 0;
1333  signers[i].rgpCounterSigner = NULL;
1334  }
1335  }
1336  else
1338  }
1339  if (err == NO_ERROR)
1340  err = policyCallback(data, TRUSTERROR_STEP_FINAL_POLICYPROV,
1341  data->dwRegPolicySettings, data->csSigners, signers, policyArg);
1342  data->psPfns->pfnFree(signers);
1343  }
1344  if (err != NO_ERROR)
1345  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_POLICYPROV] = err;
1346  TRACE("returning %d (%08x)\n", err == NO_ERROR ? S_OK : S_FALSE,
1347  data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_POLICYPROV]);
1348  return err == NO_ERROR ? S_OK : S_FALSE;
1349 }
1350 
1352 {
1353  DWORD i, j;
1354 
1355  for (i = 0; i < data->csSigners; i++)
1356  {
1357  for (j = 0; j < data->pasSigners[i].csCertChain; j++)
1358  CertFreeCertificateContext(data->pasSigners[i].pasCertChain[j].pCert);
1359  data->psPfns->pfnFree(data->pasSigners[i].pasCertChain);
1360  data->psPfns->pfnFree(data->pasSigners[i].psSigner);
1361  CertFreeCertificateChain(data->pasSigners[i].pChainContext);
1362  }
1363  data->psPfns->pfnFree(data->pasSigners);
1364 
1365  for (i = 0; i < data->chStores; i++)
1366  CertCloseStore(data->pahStores[i], 0);
1367  data->psPfns->pfnFree(data->pahStores);
1368 
1369  if (data->u.pPDSip)
1370  {
1371  data->psPfns->pfnFree(data->u.pPDSip->pSip);
1372  data->psPfns->pfnFree(data->u.pPDSip->pCATSip);
1373  data->psPfns->pfnFree(data->u.pPDSip->psSipSubjectInfo);
1374  data->psPfns->pfnFree(data->u.pPDSip->psSipCATSubjectInfo);
1375  data->psPfns->pfnFree(data->u.pPDSip->psIndirectData);
1376  }
1377 
1378  CryptMsgClose(data->hMsg);
1379 
1380  if (data->fOpenedFile &&
1381  data->pWintrustData->dwUnionChoice == WTD_CHOICE_FILE &&
1382  data->pWintrustData->u.pFile)
1383  {
1384  CloseHandle(data->pWintrustData->u.pFile->hFile);
1385  data->pWintrustData->u.pFile->hFile = INVALID_HANDLE_VALUE;
1386  data->fOpenedFile = FALSE;
1387  }
1388 
1389  return S_OK;
1390 }
1391 
1393 {
1394  FIXME("(%p)\n", data);
1395  return S_OK;
1396 }
1397 
1399 {
1400  FIXME("(%p)\n", data);
1401  return S_OK;
1402 }
BOOL WINAPI CertGetCertificateChain(HCERTCHAINENGINE hChainEngine, PCCERT_CONTEXT pCertContext, LPFILETIME pTime, HCERTSTORE hAdditionalStore, PCERT_CHAIN_PARA pChainPara, DWORD dwFlags, LPVOID pvReserved, PCCERT_CHAIN_CONTEXT *ppChainContext)
Definition: chain.c:2879
PCCERT_CONTEXT WINAPI CertGetSubjectCertificateFromStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, PCERT_INFO pCertId)
Definition: cert.c:1831
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
HRESULT WINAPI SoftpubInitialize(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:47
#define WTPF_IGNOREREVOKATION
Definition: wintrust.h:439
PCCERT_CONTEXT WINAPI CertFindCertificateInStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, DWORD dwFlags, DWORD dwType, const void *pvPara, PCCERT_CONTEXT pPrevCertContext)
Definition: cert.c:1765
CERT_ENHKEY_USAGE Usage
Definition: wincrypt.h:1048
#define CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT
Definition: wincrypt.h:882
struct _WTD_GENERIC_CHAIN_POLICY_CREATE_INFO WTD_GENERIC_CHAIN_POLICY_CREATE_INFO
#define CERT_CHAIN_POLICY_IGNORE_CA_REV_UNKNOWN_FLAG
Definition: wincrypt.h:987
HRESULT WINAPI DriverFinalPolicy(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:72
#define CloseHandle
Definition: compat.h:487
#define WTPF_TESTCANBEVALID
Definition: wintrust.h:437
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]
Definition: ntddk_ex.h:178
#define CERT_CHAIN_REVOCATION_CHECK_END_CERT
Definition: wincrypt.h:1056
#define CERT_TRUST_IS_NOT_TIME_VALID
Definition: wincrypt.h:870
#define CERT_E_UNTRUSTEDROOT
Definition: winerror.h:3125
int fileSize
Definition: main.cpp:55
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define CERT_CHAIN_POLICY_IGNORE_ROOT_REV_UNKNOWN_FLAG
Definition: wincrypt.h:988
#define CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY
Definition: wincrypt.h:887
#define TRUSTERROR_STEP_FINAL_CERTPROV
Definition: wintrust.h:277
#define ERROR_SUCCESS
Definition: deptool.c:10
unsigned int ALG_ID
Definition: wincrypt.h:45
static const struct @1655 hash_data[]
BOOL WINAPI CryptDecodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6286
#define error(str)
Definition: mkdosfs.c:1605
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
#define CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT
Definition: wincrypt.h:1058
static HRESULT WINAPI WINTRUST_DefaultPolicy(CRYPT_PROVIDER_DATA *pProvData, DWORD dwStepError, DWORD dwRegPolicySettings, DWORD cSigner, PWTD_GENERIC_CHAIN_POLICY_SIGNER_INFO rgpSigner, void *pvPolicyArg)
Definition: softpub.c:1256
#define CPD_REVOCATION_CHECK_CHAIN
Definition: wintrust.h:389
HRESULT WINAPI WintrustCertificateTrust(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:1096
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
BOOL WINAPI CryptDecodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6278
static DWORD SOFTPUB_GetFileSubject(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:110
#define TRUE
Definition: types.h:120
INT WINAPI GetDateFormatA(LCID lcid, DWORD dwFlags, const SYSTEMTIME *lpTime, LPCSTR lpFormat, LPSTR lpDateStr, INT cchOut)
Definition: lcformat.c:922
HRESULT WINAPI GenericChainCertificateTrust(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:1123
PCCERT_CHAIN_CONTEXT pChainContext
Definition: softpub.h:61
#define CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT
Definition: wincrypt.h:885
#define CERT_TRUST_IS_CYCLIC
Definition: wincrypt.h:877
INT WINAPI GetLocaleInfoA(LCID lcid, LCTYPE lctype, LPSTR buffer, INT len)
Definition: lang.c:1018
BOOL WINAPI CertFreeCertificateContext(PCCERT_CONTEXT pCertContext)
Definition: cert.c:371
#define IMAGE_DIRECTORY_ENTRY_SECURITY
Definition: pedump.c:263
CRYPT_ATTRIBUTES UnauthAttrs
Definition: wincrypt.h:776
#define CERT_E_CHAINING
Definition: winerror.h:3126
HRESULT(WINAPI * PFN_WTD_GENERIC_CHAIN_POLICY_CALLBACK)(PCRYPT_PROVIDER_DATA pProvData, DWORD dwStepError, DWORD dwRegPolicySettings, DWORD cSigner, PWTD_GENERIC_CHAIN_POLICY_SIGNER_INFO rgpSigner, void *pvPolicyArg)
Definition: softpub.h:69
#define CERT_STORE_PROV_MSG
Definition: wincrypt.h:2250
#define CMSG_CTRL_VERIFY_SIGNATURE_EX
Definition: wincrypt.h:3885
CRYPT_ATTRIBUTES AuthAttrs
Definition: wincrypt.h:3967
BOOL WINAPI CryptSIPRetrieveSubjectGuid(LPCWSTR FileName, HANDLE hFileIn, GUID *pgSubject)
Definition: sip.c:310
HRESULT WINAPI HTTPSCertificateTrust(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:1392
#define IMAGE_NT_OPTIONAL_HDR32_MAGIC
Definition: ntimage.h:376
CERT_USAGE_MATCH RequestedUsage
Definition: wincrypt.h:1070
#define INVALID_HANDLE_VALUE
Definition: compat.h:479
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define CERT_TRUST_INVALID_NAME_CONSTRAINTS
Definition: wincrypt.h:881
static DWORD WINTRUST_CopyChain(CRYPT_PROVIDER_DATA *data, DWORD signerIdx)
Definition: softpub.c:969
GLuint buffer
Definition: glext.h:5915
#define CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT
Definition: wincrypt.h:884
#define PKCS_7_ASN_ENCODING
Definition: wincrypt.h:2299
GLuint GLuint end
Definition: gl.h:1545
#define FILE_BEGIN
Definition: compat.h:509
__u16 time
Definition: mkdosfs.c:366
#define CERT_FIND_SIGNATURE_HASH
Definition: wincrypt.h:2869
BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore, HCERTSTORE hSiblingStore, DWORD dwUpdateFlags, DWORD dwPriority)
char * LPSTR
Definition: xmlstorage.h:182
struct _WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO * rgpCounterSigner
Definition: softpub.h:66
#define NO_ERROR
Definition: dderror.h:5
VOID WINAPI CertFreeCertificateChain(PCCERT_CHAIN_CONTEXT pChainContext)
Definition: chain.c:2960
#define CERT_STORE_PROV_COLLECTION
Definition: wincrypt.h:2261
PWTD_GENERIC_CHAIN_POLICY_CREATE_INFO pSignerChainInfo
Definition: softpub.h:92
#define FILE_SHARE_READ
Definition: compat.h:136
#define CMSG_INNER_CONTENT_TYPE_PARAM
Definition: wincrypt.h:3928
BOOL WINAPI CertVerifyCertificateChainPolicy(LPCSTR szPolicyOID, PCCERT_CHAIN_CONTEXT pChainContext, PCERT_CHAIN_POLICY_PARA pPolicyPara, PCERT_CHAIN_POLICY_STATUS pPolicyStatus)
Definition: chain.c:3716
#define HP_HASHSIZE
Definition: wincrypt.h:2184
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define CMS_SIGNER_INFO
Definition: wincrypt.h:3437
HCRYPTMSG WINAPI CryptMsgOpenToDecode(DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, HCRYPTPROV_LEGACY hCryptProv, PCERT_INFO pRecipientInfo, PCMSG_STREAM_INFO pStreamInfo)
Definition: msg.c:3552
BOOL WINAPI CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
Definition: crypt.c:358
#define IMAGE_DOS_SIGNATURE
Definition: pedump.c:89
#define CERT_CONFIDENCE_SIG
Definition: wintrust.h:224
#define CERT_TRUST_IS_SELF_SIGNED
Definition: wincrypt.h:899
#define CERT_TRUST_IS_REVOKED
Definition: wincrypt.h:872
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
#define CERT_E_VALIDITYPERIODNESTING
Definition: winerror.h:3118
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
struct _CERT_CHAIN_PARA CERT_CHAIN_PARA
BOOL WINAPI CertGetCertificateContextProperty(PCCERT_CONTEXT pCertContext, DWORD dwPropId, void *pvData, DWORD *pcbData)
Definition: cert.c:551
unsigned char * LPBYTE
Definition: typedefs.h:53
#define CERT_STORE_CREATE_NEW_FLAG
Definition: wincrypt.h:2464
BOOL WINAPI CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags)
Definition: crypt.c:1610
#define FALSE
Definition: types.h:117
int hash
Definition: main.c:58
static DWORD WINTRUST_TrustStatusToConfidence(DWORD errorStatus)
Definition: softpub.c:869
unsigned int BOOL
Definition: ntddk_ex.h:94
static DWORD SOFTPUB_DecodeInnerContent(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:400
#define CERT_CHAIN_POLICY_BASE
Definition: wincrypt.h:962
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
Definition: crypt.c:648
PCCERT_CONTEXT pCertContext
Definition: wincrypt.h:916
#define CERT_E_WRONG_USAGE
Definition: winerror.h:3132
#define FIXME(fmt,...)
Definition: debug.h:111
HRESULT WINAPI DriverCleanupPolicy(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:66
#define PROV_RSA_AES
Definition: wincrypt.h:2056
#define CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG
Definition: wincrypt.h:999
struct _WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:888
#define S_FALSE
Definition: winerror.h:2357
#define CMSG_VERIFY_SIGNER_CERT
Definition: wincrypt.h:3921
static BOOL hash_file_data(HANDLE file, DWORD start, DWORD end, HCRYPTHASH hash)
Definition: softpub.c:213
#define CERT_CHAIN_POLICY_IGNORE_NOT_TIME_NESTED_FLAG
Definition: wincrypt.h:972
#define WTD_CHOICE_FILE
Definition: wintrust.h:91
smooth NULL
Definition: ftsmooth.c:416
#define CERT_TRUST_REVOCATION_STATUS_UNKNOWN
Definition: wincrypt.h:876
BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
Definition: store.c:1127
WINE_DEFAULT_DEBUG_CHANNEL(wintrust)
_In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_opt_ HCERTSTORE _In_ PCERT_CHAIN_PARA pChainPara
Definition: wincrypt.h:4836
#define TRUSTERROR_STEP_FINAL_WVTINIT
Definition: wintrust.h:273
static DWORD SOFTPUB_CreateStoreFromMessage(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:381
const char * LPCSTR
Definition: xmlstorage.h:183
static DWORD SOFTPUB_LoadCatalogMessage(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:560
#define CERT_TRUST_INVALID_EXTENSION
Definition: wincrypt.h:878
#define OPEN_EXISTING
Definition: compat.h:523
#define TRUSTERROR_STEP_FINAL_POLICYPROV
Definition: wintrust.h:279
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
struct SIP_SUBJECTINFO_ SIP_SUBJECTINFO
#define IMAGE_NT_SIGNATURE
Definition: pedump.c:93
struct _FILETIME FILETIME
#define TRUST_E_BASIC_CONSTRAINTS
Definition: winerror.h:3110
static CERT_INFO * WINTRUST_GetSignerCertInfo(CRYPT_PROVIDER_DATA *data, DWORD signerIdx)
Definition: softpub.c:770
PFN_WTD_GENERIC_CHAIN_POLICY_CALLBACK pfnPolicyCallback
Definition: softpub.h:94
PCMSG_SIGNER_INFO pMsgSignerInfo
Definition: softpub.h:63
#define SPC_PE_IMAGE_DATA_OBJID
Definition: wintrust.h:486
#define CERT_CONFIDENCE_TIME
Definition: wintrust.h:225
static IMAGE_DOS_HEADER dos_header
Definition: data.c:13
VOID WINAPI GetSystemTime(OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:327
#define TRACE(s)
Definition: solgame.cpp:4
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:188
GLsizeiptr size
Definition: glext.h:5919
FILETIME sftVerifyAsOf
Definition: wintrust.h:233
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
CERT_TRUST_STATUS TrustStatus
Definition: wincrypt.h:917
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define CERT_SIGNATURE_HASH_PROP_ID
Definition: wincrypt.h:2701
#define debugstr_a
Definition: kernel32.h:31
#define TRUST_E_NOSIGNATURE
Definition: winerror.h:3116
LONG HRESULT
Definition: typedefs.h:79
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define CERT_CHAIN_POLICY_AUTHENTICODE
Definition: wincrypt.h:963
#define WTD_CHOICE_CATALOG
Definition: wintrust.h:92
#define CERT_E_REVOCATION_FAILURE
Definition: winerror.h:3130
#define CERT_CONFIDENCE_TIMENEST
Definition: wintrust.h:226
#define CERT_CHAIN_REVOCATION_CHECK_CHAIN
Definition: wincrypt.h:1057
#define TRUST_E_SUBJECT_NOT_TRUSTED
Definition: winerror.h:3115
#define WINAPI
Definition: msvc.h:6
const char file[]
Definition: icontest.c:11
#define LOCALE_SYSTEM_DEFAULT
#define TRUST_E_SYSTEM_ERROR
Definition: winerror.h:3104
unsigned long DWORD
Definition: ntddk_ex.h:95
#define CERT_E_CRITICAL
Definition: winerror.h:3121
#define SetLastError(x)
Definition: compat.h:500
Definition: cookie.c:201
#define IMAGE_NT_OPTIONAL_HDR64_MAGIC
Definition: ntimage.h:377
static void WINTRUST_CreateChainPolicyCreateInfo(const CRYPT_PROVIDER_DATA *data, PWTD_GENERIC_CHAIN_POLICY_CREATE_INFO info, PCERT_CHAIN_PARA chainPara)
Definition: softpub.c:1002
#define CERT_TRUST_IS_NOT_SIGNATURE_VALID
Definition: wincrypt.h:873
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
BOOL WINAPI SoftpubCheckCert(CRYPT_PROVIDER_DATA *data, DWORD idxSigner, BOOL fCounterSignerChain, DWORD idxCounterSigner)
Definition: softpub.c:883
BOOL WINAPI CryptDestroyHash(HCRYPTHASH hHash)
Definition: crypt.c:890
HRESULT WINAPI GenericChainFinalProv(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:1284
#define TRUST_E_BAD_DIGEST
Definition: winerror.h:3109
#define GetFileSizeEx
Definition: compat.h:505
int ret
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define WTPF_TRUSTTEST
Definition: wintrust.h:436
#define CERT_E_INVALID_POLICY
Definition: winerror.h:3135
#define LOCALE_SSHORTDATE
Definition: winnls.h:60
#define WTPF_IGNOREEXPIRATION
Definition: wintrust.h:438
static DWORD SOFTPUB_VerifyImageHash(CRYPT_PROVIDER_DATA *data, HANDLE file)
Definition: softpub.c:309
HRESULT WINAPI SoftpubCleanup(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:1351
BOOL WINAPI CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash)
Definition: crypt.c:740
static LPCSTR filetime_to_str(const FILETIME *time)
Definition: softpub.c:690
static const WCHAR disallowed[]
Definition: main.c:459
#define GENERIC_READ
Definition: compat.h:135
static cab_ULONG checksum(const cab_UBYTE *data, cab_UWORD bytes, cab_ULONG csum)
Definition: fdi.c:353
#define err(...)
static DWORD SOFTPUB_LoadFileMessage(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:518
static const WCHAR MS_ENH_RSA_AES_PROV_W[]
Definition: wincrypt.h:2012
static DWORD SOFTPUB_LoadCertMessage(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:469
unsigned char BYTE
Definition: xxhash.c:193
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
HRESULT WINAPI SoftpubLoadMessage(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:599
HRESULT WINAPI DriverInitializePolicy(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:60
ed encoding
Definition: write.c:2825
#define CPD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT
Definition: wintrust.h:390
#define CRYPT_VERIFYCONTEXT
Definition: wincrypt.h:2069
HRESULT WINAPI SoftpubLoadSignature(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:833
ULONG_PTR HCRYPTHASH
Definition: wincrypt.h:50
#define CERT_TRUST_INVALID_POLICY_CONSTRAINTS
Definition: wincrypt.h:879
#define CERT_TRUST_IS_NOT_TIME_NESTED
Definition: wincrypt.h:871
PCRYPT_ATTRIBUTE rgAttr
Definition: wincrypt.h:595
DWORD WINAPI CertOIDToAlgId(LPCSTR pszObjId)
Definition: oid.c:1901
#define TRUSTERROR_STEP_FINAL_SIGPROV
Definition: wintrust.h:276
#define S_OK
Definition: intsafe.h:51
#define CERT_TRUST_IS_NOT_VALID_FOR_USAGE
Definition: wincrypt.h:874
BOOL WINAPI SystemTimeToFileTime(IN CONST SYSTEMTIME *lpSystemTime, OUT LPFILETIME lpFileTime)
Definition: time.c:158
#define TRUST_E_NO_SIGNER_CERT
Definition: winerror.h:3105
#define CERT_STORE_PROV_SYSTEM_W
Definition: wincrypt.h:2259
#define TRUSTERROR_STEP_FINAL_OBJPROV
Definition: wintrust.h:275
static BOOL WINTRUST_GetTimeFromCounterSigner(const CMSG_CMS_SIGNER_INFO *counterSignerInfo, FILETIME *time)
Definition: softpub.c:659
PCERT_CHAIN_ELEMENT * rgpElement
Definition: wincrypt.h:928
#define TRUST_E_SUBJECT_FORM_UNKNOWN
Definition: winerror.h:3114
DWORD cUsageIdentifier
Definition: wincrypt.h:719
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
#define WVT_ISINSTRUCT(t, s, f)
Definition: wintrust.h:433
GLuint start
Definition: gl.h:1545
#define ARRAY_SIZE(a)
Definition: main.h:24
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
#define CERT_SYSTEM_STORE_CURRENT_USER
Definition: wincrypt.h:2324
__u16 date
Definition: mkdosfs.c:366
#define CERT_CHAIN_POLICY_IGNORE_CTL_NOT_TIME_VALID_FLAG
Definition: wincrypt.h:971
#define E_NOTIMPL
Definition: ddrawi.h:99
#define TRUST_E_CERT_SIGNATURE
Definition: winerror.h:3107
BOOL WINAPI CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)
Definition: crypt.c:1771
#define CERT_CHAIN_POLICY_IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG
Definition: wincrypt.h:986
CMSG_SIGNER_INFO * psSigner
Definition: wintrust.h:237
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define ReadFile(a, b, c, d, e)
Definition: compat.h:490
static BOOL SOFTPUB_HashPEFile(HANDLE file, HCRYPTHASH hash)
Definition: softpub.c:235
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
#define min(a, b)
Definition: monoChain.cc:55
BOOL WINAPI CryptSIPLoad(const GUID *pgSubject, DWORD dwFlags, SIP_DISPATCH_INFO *pSipDispatch)
Definition: sip.c:690
static DWORD WINTRUST_TrustStatusToError(DWORD errorStatus)
Definition: softpub.c:924
static DWORD WINTRUST_CreateChainForSigner(CRYPT_PROVIDER_DATA *data, DWORD signer, PWTD_GENERIC_CHAIN_POLICY_CREATE_INFO createInfo, PCERT_CHAIN_PARA chainPara)
Definition: softpub.c:1028
#define szOID_RSA_signingTime
Definition: wincrypt.h:3039
#define WTD_CHOICE_CERT
Definition: wintrust.h:95
HCERTSTORE WINAPI CertOpenStore(LPCSTR lpszStoreProvider, DWORD dwMsgAndCertEncodingType, HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:815
#define CreateFileW
Definition: compat.h:489
#define CERT_TRUST_IS_UNTRUSTED_ROOT
Definition: wincrypt.h:875
BOOL WINAPI CryptMsgClose(HCRYPTMSG hCryptMsg)
Definition: msg.c:3597
static DWORD SOFTPUB_OpenFile(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:81
BOOL WINAPI CryptMsgUpdate(HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
Definition: msg.c:3616
#define CERT_STORE_NO_CRYPT_RELEASE_FLAG
Definition: wincrypt.h:2452
static DWORD WINTRUST_VerifySigner(CRYPT_PROVIDER_DATA *data, DWORD signerIdx)
Definition: softpub.c:798
#define X509_CHOICE_OF_TIME
Definition: wincrypt.h:3397
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define CPD_REVOCATION_CHECK_END_CERT
Definition: wintrust.h:388
BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:3626
#define CMSG_SIGNER_CERT_INFO_PARAM
Definition: wincrypt.h:3931
#define CERT_TRUST_IS_OFFLINE_REVOCATION
Definition: wincrypt.h:886
HRESULT WINAPI HTTPSFinalProv(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:1398
#define CMSG_SIGNER_INFO_PARAM
Definition: wincrypt.h:3930
#define WTD_UI_NONE
Definition: wintrust.h:84
#define HP_HASHVAL
Definition: wincrypt.h:2183
#define CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG
Definition: wincrypt.h:998
static DWORD WINTRUST_SaveSigner(CRYPT_PROVIDER_DATA *data, DWORD signerIdx)
Definition: softpub.c:749
Definition: _hash_fun.h:40
#define CERT_CHAIN_POLICY_IGNORE_END_REV_UNKNOWN_FLAG
Definition: wincrypt.h:985
#define szOID_RSA_counterSign
Definition: wincrypt.h:3040
static DWORD SOFTPUB_GetMessageFromFile(CRYPT_PROVIDER_DATA *data, HANDLE file, LPCWSTR filePath)
Definition: softpub.c:165
#define WVT_IS_CBSTRUCT_GT_MEMBEROFFSET(t, s, f)
Definition: wintrust.h:434
static FILETIME WINTRUST_GetTimeFromSigner(const CRYPT_PROVIDER_DATA *data, const CMSG_SIGNER_INFO *signerInfo)
Definition: softpub.c:704
BOOL WINAPI GetFileTime(IN HANDLE hFile, OUT LPFILETIME lpCreationTime OPTIONAL, OUT LPFILETIME lpLastAccessTime OPTIONAL, OUT LPFILETIME lpLastWriteTime OPTIONAL)
Definition: fileinfo.c:1046
#define HeapFree(x, y, z)
Definition: compat.h:483
static IMAGE_NT_HEADERS32 nt_header
Definition: data.c:36
#define SetFilePointer
Definition: compat.h:491
#define CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT
Definition: wincrypt.h:883
#define file_size(inode)
Definition: reiserfs_fs.h:1869
BOOL WINAPI CryptMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, const void *pvCtrlPara)
Definition: msg.c:3636
#define CMSG_SIGNER_COUNT_PARAM
Definition: wincrypt.h:3929
#define CERT_E_EXPIRED
Definition: winerror.h:3117
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
HRESULT WINAPI SoftpubDefCertInit(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:34
HRESULT WINAPI SoftpubAuthenticode(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:1170
static DWORD SOFTPUB_GetSIP(CRYPT_PROVIDER_DATA *data)
Definition: softpub.c:146
#define CERT_E_REVOKED
Definition: winerror.h:3128
#define CERT_CHAIN_POLICY_IGNORE_NOT_TIME_VALID_FLAG
Definition: wincrypt.h:970
static CMSG_SIGNER_INFO * WINTRUST_GetSigner(CRYPT_PROVIDER_DATA *data, DWORD signerIdx)
Definition: softpub.c:631
Definition: fci.c:126
#define CERT_E_INVALID_NAME
Definition: winerror.h:3136
#define CERT_TRUST_INVALID_BASIC_CONSTRAINTS
Definition: wincrypt.h:880