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