ReactOS  0.4.11-dev-195-gef016bf
register.c
Go to the documentation of this file.
1 /*
2  * Register related wintrust functions
3  *
4  * Copyright 2006 Paul Vriens
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20 
21 #include <stdarg.h>
22 
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winerror.h"
26 #include "winuser.h"
27 #include "winreg.h"
28 #include "winnls.h"
29 #include "objbase.h"
30 
31 #include "guiddef.h"
32 #include "wintrust.h"
33 #include "softpub.h"
34 #include "mssip.h"
35 #include "wintrust_priv.h"
36 #include "wine/debug.h"
37 
39 
47 
49 
51 
54 
57 
61 
64 
65 static const CRYPT_TRUST_REG_ENTRY NullCTRE = { 0, NULL, NULL };
66 
67 static const WCHAR Trust[] = {'S','o','f','t','w','a','r','e','\\',
68  'M','i','c','r','o','s','o','f','t','\\',
69  'C','r','y','p','t','o','g','r','a','p','h','y','\\',
70  'P','r','o','v','i','d','e','r','s','\\',
71  'T','r','u','s','t','\\', 0 };
72 
73 static const WCHAR Initialization[] = {'I','n','i','t','i','a','l','i','z','a','t','i','o','n','\\', 0};
74 static const WCHAR Message[] = {'M','e','s','s','a','g','e','\\', 0};
75 static const WCHAR Signature[] = {'S','i','g','n','a','t','u','r','e','\\', 0};
76 static const WCHAR Certificate[] = {'C','e','r','t','i','f','i','c','a','t','e','\\', 0};
77 static const WCHAR CertCheck[] = {'C','e','r','t','C','h','e','c','k','\\', 0};
78 static const WCHAR FinalPolicy[] = {'F','i','n','a','l','P','o','l','i','c','y','\\', 0};
79 static const WCHAR DiagnosticPolicy[] = {'D','i','a','g','n','o','s','t','i','c','P','o','l','i','c','y','\\', 0};
80 static const WCHAR Cleanup[] = {'C','l','e','a','n','u','p','\\', 0};
81 
82 static const WCHAR DefaultId[] = {'D','e','f','a','u','l','t','I','d', 0};
83 static const WCHAR Dll[] = {'$','D','L','L', 0};
84 
85 /***********************************************************************
86  * WINTRUST_InitRegStructs
87  *
88  * Helper function to allocate and initialize the members of the
89  * CRYPT_TRUST_REG_ENTRY structs.
90  */
91 static void WINTRUST_InitRegStructs(void)
92 {
93 #define WINTRUST_INITREGENTRY( action, dllname, functionname ) \
94  action.cbStruct = sizeof(CRYPT_TRUST_REG_ENTRY); \
95  action.pwszDLLName = WINTRUST_Alloc(sizeof(dllname)); \
96  lstrcpyW(action.pwszDLLName, dllname); \
97  action.pwszFunctionName = WINTRUST_Alloc(sizeof(functionname)); \
98  lstrcpyW(action.pwszFunctionName, functionname);
99 
118 
119 #undef WINTRUST_INITREGENTRY
120 }
121 
122 /***********************************************************************
123  * WINTRUST_FreeRegStructs
124  *
125  * Helper function to free 2 members of the CRYPT_TRUST_REG_ENTRY
126  * structs.
127  */
128 static void WINTRUST_FreeRegStructs(void)
129 {
130 #define WINTRUST_FREEREGENTRY( action ) \
131  WINTRUST_Free(action.pwszDLLName); \
132  WINTRUST_Free(action.pwszFunctionName);
133 
134  WINTRUST_FREEREGENTRY(SoftpubInitialization);
135  WINTRUST_FREEREGENTRY(SoftpubMessage);
136  WINTRUST_FREEREGENTRY(SoftpubSignature);
137  WINTRUST_FREEREGENTRY(SoftpubCertificate);
138  WINTRUST_FREEREGENTRY(SoftpubCertCheck);
139  WINTRUST_FREEREGENTRY(SoftpubFinalPolicy);
140  WINTRUST_FREEREGENTRY(SoftpubCleanup);
141  WINTRUST_FREEREGENTRY(SoftpubDefCertInit);
142  WINTRUST_FREEREGENTRY(SoftpubDumpStructure);
143  WINTRUST_FREEREGENTRY(HTTPSCertificateTrust);
144  WINTRUST_FREEREGENTRY(HTTPSFinalProv);
145  WINTRUST_FREEREGENTRY(OfficeInitializePolicy);
146  WINTRUST_FREEREGENTRY(OfficeCleanupPolicy);
147  WINTRUST_FREEREGENTRY(DriverInitializePolicy);
148  WINTRUST_FREEREGENTRY(DriverFinalPolicy);
149  WINTRUST_FREEREGENTRY(DriverCleanupPolicy);
150  WINTRUST_FREEREGENTRY(GenericChainCertificateTrust);
151  WINTRUST_FREEREGENTRY(GenericChainFinalProv);
152 
153 #undef WINTRUST_FREEREGENTRY
154 }
155 
156 /***********************************************************************
157  * WINTRUST_guid2wstr
158  *
159  * Create a wide-string from a GUID
160  *
161  */
162 static void WINTRUST_Guid2Wstr(const GUID* pgActionID, WCHAR* GuidString)
163 {
164  static const WCHAR wszFormat[] = {'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
165  '%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
166  'X','%','0','2','X','%','0','2','X','}', 0};
167 
168  wsprintfW(GuidString, wszFormat, pgActionID->Data1, pgActionID->Data2, pgActionID->Data3,
169  pgActionID->Data4[0], pgActionID->Data4[1], pgActionID->Data4[2], pgActionID->Data4[3],
170  pgActionID->Data4[4], pgActionID->Data4[5], pgActionID->Data4[6], pgActionID->Data4[7]);
171 }
172 
173 /***********************************************************************
174  * WINTRUST_WriteProviderToReg
175  *
176  * Helper function for WintrustAddActionID
177  *
178  */
180  const WCHAR* FunctionType,
182 {
183  static const WCHAR Function[] = {'$','F','u','n','c','t','i','o','n', 0};
184  WCHAR ProvKey[MAX_PATH];
185  HKEY Key;
186  LONG Res = ERROR_SUCCESS;
187 
188  /* Create the needed key string */
189  ProvKey[0]='\0';
190  lstrcatW(ProvKey, Trust);
191  lstrcatW(ProvKey, FunctionType);
192  lstrcatW(ProvKey, GuidString);
193 
194  if (!RegEntry.pwszDLLName || !RegEntry.pwszFunctionName)
196 
197  Res = RegCreateKeyExW(HKEY_LOCAL_MACHINE, ProvKey, 0, NULL, 0, KEY_WRITE, NULL, &Key, NULL);
198  if (Res != ERROR_SUCCESS) goto error_close_key;
199 
200  /* Create the $DLL entry */
201  Res = RegSetValueExW(Key, Dll, 0, REG_SZ, (BYTE*)RegEntry.pwszDLLName,
202  (lstrlenW(RegEntry.pwszDLLName) + 1)*sizeof(WCHAR));
203  if (Res != ERROR_SUCCESS) goto error_close_key;
204 
205  /* Create the $Function entry */
206  Res = RegSetValueExW(Key, Function, 0, REG_SZ, (BYTE*)RegEntry.pwszFunctionName,
207  (lstrlenW(RegEntry.pwszFunctionName) + 1)*sizeof(WCHAR));
208 
209 error_close_key:
210  RegCloseKey(Key);
211 
212  return Res;
213 }
214 
215 /***********************************************************************
216  * WintrustAddActionID (WINTRUST.@)
217  *
218  * Add the definitions of the actions a Trust provider can perform to
219  * the registry.
220  *
221  * PARAMS
222  * pgActionID [I] Pointer to a GUID for the Trust provider.
223  * fdwFlags [I] Flag to indicate whether registry errors are passed on.
224  * psProvInfo [I] Pointer to a structure with information about DLL
225  * name and functions.
226  *
227  * RETURNS
228  * Success: TRUE.
229  * Failure: FALSE. (Use GetLastError() for more information)
230  *
231  * NOTES
232  * Adding definitions is basically only adding relevant information
233  * to the registry. No verification takes place whether a DLL or its
234  * entrypoints exist.
235  * Information in the registry will always be overwritten.
236  *
237  */
238 BOOL WINAPI WintrustAddActionID( GUID* pgActionID, DWORD fdwFlags,
239  CRYPT_REGISTER_ACTIONID* psProvInfo)
240 {
241  WCHAR GuidString[39];
242  LONG Res;
243  LONG WriteActionError = ERROR_SUCCESS;
244 
245  TRACE("%s %x %p\n", debugstr_guid(pgActionID), fdwFlags, psProvInfo);
246 
247  /* Some sanity checks.
248  * We use the W2K3 last error as it makes more sense (W2K leaves the last error
249  * as is).
250  */
251  if (!pgActionID ||
252  !psProvInfo ||
253  (psProvInfo->cbStruct != sizeof(CRYPT_REGISTER_ACTIONID)))
254  {
256  return FALSE;
257  }
258 
259  /* Create this string only once, instead of in the helper function */
260  WINTRUST_Guid2Wstr( pgActionID, GuidString);
261 
262  /* Write the information to the registry */
263  Res = WINTRUST_WriteProviderToReg(GuidString, Initialization , psProvInfo->sInitProvider);
264  if (Res != ERROR_SUCCESS) WriteActionError = Res;
265  Res = WINTRUST_WriteProviderToReg(GuidString, Message , psProvInfo->sObjectProvider);
266  if (Res != ERROR_SUCCESS) WriteActionError = Res;
267  Res = WINTRUST_WriteProviderToReg(GuidString, Signature , psProvInfo->sSignatureProvider);
268  if (Res != ERROR_SUCCESS) WriteActionError = Res;
269  Res = WINTRUST_WriteProviderToReg(GuidString, Certificate , psProvInfo->sCertificateProvider);
270  if (Res != ERROR_SUCCESS) WriteActionError = Res;
271  Res = WINTRUST_WriteProviderToReg(GuidString, CertCheck , psProvInfo->sCertificatePolicyProvider);
272  if (Res != ERROR_SUCCESS) WriteActionError = Res;
273  Res = WINTRUST_WriteProviderToReg(GuidString, FinalPolicy , psProvInfo->sFinalPolicyProvider);
274  if (Res != ERROR_SUCCESS) WriteActionError = Res;
275  Res = WINTRUST_WriteProviderToReg(GuidString, DiagnosticPolicy, psProvInfo->sTestPolicyProvider);
276  if (Res != ERROR_SUCCESS) WriteActionError = Res;
277  Res = WINTRUST_WriteProviderToReg(GuidString, Cleanup , psProvInfo->sCleanupProvider);
278  if (Res != ERROR_SUCCESS) WriteActionError = Res;
279 
280  /* Testing (by restricting access to the registry for some keys) shows that the last failing function
281  * will be used for last error.
282  * If the flag WT_ADD_ACTION_ID_RET_RESULT_FLAG is set and there are errors when adding the action
283  * we have to return FALSE. Errors includes both invalid entries as well as registry errors.
284  * Testing also showed that one error doesn't stop the registry writes. Every action will be dealt with.
285  */
286 
287  if (WriteActionError != ERROR_SUCCESS)
288  {
289  SetLastError(WriteActionError);
290 
291  if (fdwFlags == WT_ADD_ACTION_ID_RET_RESULT_FLAG)
292  return FALSE;
293  }
294 
295  return TRUE;
296 }
297 
298 /***********************************************************************
299  * WINTRUST_RemoveProviderFromReg
300  *
301  * Helper function for WintrustRemoveActionID
302  *
303  */
305  const WCHAR* FunctionType)
306 {
307  WCHAR ProvKey[MAX_PATH];
308 
309  /* Create the needed key string */
310  ProvKey[0]='\0';
311  lstrcatW(ProvKey, Trust);
312  lstrcatW(ProvKey, FunctionType);
313  lstrcatW(ProvKey, GuidString);
314 
315  /* We don't care about success or failure */
317 }
318 
319 /***********************************************************************
320  * WintrustRemoveActionID (WINTRUST.@)
321  *
322  * Remove the definitions of the actions a Trust provider can perform
323  * from the registry.
324  *
325  * PARAMS
326  * pgActionID [I] Pointer to a GUID for the Trust provider.
327  *
328  * RETURNS
329  * Success: TRUE. (Use GetLastError() for more information)
330  * Failure: FALSE. (Use GetLastError() for more information)
331  *
332  * NOTES
333  * Testing shows that WintrustRemoveActionID always returns TRUE and
334  * that a possible error should be retrieved via GetLastError().
335  * There are no checks if the definitions are in the registry.
336  */
338 {
339  WCHAR GuidString[39];
340 
341  TRACE("(%s)\n", debugstr_guid(pgActionID));
342 
343  if (!pgActionID)
344  {
346  return TRUE;
347  }
348 
349  /* Create this string only once, instead of in the helper function */
350  WINTRUST_Guid2Wstr( pgActionID, GuidString);
351 
352  /* We don't care about success or failure */
361 
362  return TRUE;
363 }
364 
365 /***********************************************************************
366  * WINTRUST_WriteSingleUsageEntry
367  *
368  * Helper for WintrustAddDefaultForUsage, writes a single value and its
369  * data to:
370  *
371  * HKLM\Software\Microsoft\Cryptography\Trust\Usages<OID>
372  */
374  const WCHAR* Value,
375  WCHAR* Data)
376 {
377  static const WCHAR Usages[] = {'U','s','a','g','e','s','\\', 0};
378  WCHAR* UsageKey;
379  HKEY Key;
380  LONG Res = ERROR_SUCCESS;
381  WCHAR* OIDW;
382  DWORD Len;
383 
384  /* Turn OID into a wide-character string */
385  Len = MultiByteToWideChar( CP_ACP, 0, OID, -1, NULL, 0 );
386  OIDW = WINTRUST_Alloc( Len * sizeof(WCHAR) );
387  MultiByteToWideChar( CP_ACP, 0, OID, -1, OIDW, Len );
388 
389  /* Allocate the needed space for UsageKey */
390  UsageKey = WINTRUST_Alloc((lstrlenW(Trust) + lstrlenW(Usages) + Len) * sizeof(WCHAR));
391  /* Create the key string */
392  lstrcpyW(UsageKey, Trust);
393  lstrcatW(UsageKey, Usages);
394  lstrcatW(UsageKey, OIDW);
395 
396  Res = RegCreateKeyExW(HKEY_LOCAL_MACHINE, UsageKey, 0, NULL, 0, KEY_WRITE, NULL, &Key, NULL);
397  if (Res == ERROR_SUCCESS)
398  {
399  /* Create the Value entry */
400  Res = RegSetValueExW(Key, Value, 0, REG_SZ, (BYTE*)Data,
401  (lstrlenW(Data) + 1)*sizeof(WCHAR));
402  }
403  RegCloseKey(Key);
404 
405  WINTRUST_Free(OIDW);
406  WINTRUST_Free(UsageKey);
407 
408  return Res;
409 }
410 
411 /***************************************************************************
412  * WINTRUST_RegisterGenVerifyV2
413  *
414  * Register WINTRUST_ACTION_GENERIC_VERIFY_V2 actions and usages.
415  *
416  * NOTES
417  * WINTRUST_ACTION_GENERIC_VERIFY_V2 ({00AAC56B-CD44-11D0-8CC2-00C04FC295EE}
418  * is defined in softpub.h
419  */
421 {
422  BOOL RegisteredOK = TRUE;
423  static GUID ProvGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
424  CRYPT_REGISTER_ACTIONID ProvInfo;
426  &ProvGUID,
427  NULL, /* No Dll provided */
428  NULL, /* No load callback function */
429  NULL }; /* No free callback function */
430 
431  ProvInfo.cbStruct = sizeof(CRYPT_REGISTER_ACTIONID);
433  ProvInfo.sObjectProvider = SoftpubMessage;
438  ProvInfo.sTestPolicyProvider = NullCTRE; /* No diagnostic policy */
439  ProvInfo.sCleanupProvider = SoftpubCleanup;
440 
442  RegisteredOK = FALSE;
443 
444  if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
445  RegisteredOK = FALSE;
446 
447  return RegisteredOK;
448 }
449 
450 /***************************************************************************
451  * WINTRUST_RegisterPublishedSoftware
452  *
453  * Register WIN_SPUB_ACTION_PUBLISHED_SOFTWARE actions and usages.
454  *
455  * NOTES
456  * WIN_SPUB_ACTION_PUBLISHED_SOFTWARE ({64B9D180-8DA2-11CF-8736-00AA00A485EB})
457  * is defined in wintrust.h
458  */
460 {
461  static GUID ProvGUID = WIN_SPUB_ACTION_PUBLISHED_SOFTWARE;
462  CRYPT_REGISTER_ACTIONID ProvInfo;
463 
464  ProvInfo.cbStruct = sizeof(CRYPT_REGISTER_ACTIONID);
466  ProvInfo.sObjectProvider = SoftpubMessage;
471  ProvInfo.sTestPolicyProvider = NullCTRE; /* No diagnostic policy */
472  ProvInfo.sCleanupProvider = SoftpubCleanup;
473 
474  if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
475  return FALSE;
476 
477  return TRUE;
478 }
479 
480 #define WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI { 0xc6b2e8d0, 0xe005, 0x11cf, { 0xa1,0x34,0x00,0xc0,0x4f,0xd7,0xbf,0x43 }}
481 
482 /***************************************************************************
483  * WINTRUST_RegisterPublishedSoftwareNoBadUi
484  *
485  * Register WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI actions and usages.
486  *
487  * NOTES
488  * WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI ({C6B2E8D0-E005-11CF-A134-00C04FD7BF43})
489  * is not defined in any include file. (FIXME: Find out if the name is correct).
490  */
492 {
494  CRYPT_REGISTER_ACTIONID ProvInfo;
495 
496  ProvInfo.cbStruct = sizeof(CRYPT_REGISTER_ACTIONID);
498  ProvInfo.sObjectProvider = SoftpubMessage;
503  ProvInfo.sTestPolicyProvider = NullCTRE; /* No diagnostic policy */
504  ProvInfo.sCleanupProvider = SoftpubCleanup;
505 
506  if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
507  return FALSE;
508 
509  return TRUE;
510 }
511 
512 /***************************************************************************
513  * WINTRUST_RegisterGenCertVerify
514  *
515  * Register WINTRUST_ACTION_GENERIC_CERT_VERIFY actions and usages.
516  *
517  * NOTES
518  * WINTRUST_ACTION_GENERIC_CERT_VERIFY ({189A3842-3041-11D1-85E1-00C04FC295EE})
519  * is defined in softpub.h
520  */
522 {
523  static GUID ProvGUID = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
524  CRYPT_REGISTER_ACTIONID ProvInfo;
525 
526  ProvInfo.cbStruct = sizeof(CRYPT_REGISTER_ACTIONID);
528  ProvInfo.sObjectProvider = SoftpubMessage;
533  ProvInfo.sTestPolicyProvider = NullCTRE; /* No diagnostic policy */
534  ProvInfo.sCleanupProvider = SoftpubCleanup;
535 
536  if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
537  return FALSE;
538 
539  return TRUE;
540 }
541 
542 /***************************************************************************
543  * WINTRUST_RegisterTrustProviderTest
544  *
545  * Register WINTRUST_ACTION_TRUSTPROVIDER_TEST actions and usages.
546  *
547  * NOTES
548  * WINTRUST_ACTION_TRUSTPROVIDER_TEST ({573E31F8-DDBA-11D0-8CCB-00C04FC295EE})
549  * is defined in softpub.h
550  */
552 {
553  static GUID ProvGUID = WINTRUST_ACTION_TRUSTPROVIDER_TEST;
554  CRYPT_REGISTER_ACTIONID ProvInfo;
555 
556  ProvInfo.cbStruct = sizeof(CRYPT_REGISTER_ACTIONID);
558  ProvInfo.sObjectProvider = SoftpubMessage;
564  ProvInfo.sCleanupProvider = SoftpubCleanup;
565 
566  if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
567  return FALSE;
568 
569  return TRUE;
570 }
571 
572 /***************************************************************************
573  * WINTRUST_RegisterHttpsProv
574  *
575  * Register HTTPSPROV_ACTION actions and usages.
576  *
577  * NOTES
578  * HTTPSPROV_ACTION ({573E31F8-AABA-11D0-8CCB-00C04FC295EE})
579  * is defined in softpub.h
580  */
582 {
583  BOOL RegisteredOK = TRUE;
584  static CHAR SoftpubLoadUsage[] = "SoftpubLoadDefUsageCallData";
585  static CHAR SoftpubFreeUsage[] = "SoftpubFreeDefUsageCallData";
586  static GUID ProvGUID = HTTPSPROV_ACTION;
587  CRYPT_REGISTER_ACTIONID ProvInfo;
589  &ProvGUID,
590  NULL, /* Will be filled later */
591  SoftpubLoadUsage,
592  SoftpubFreeUsage };
593 
594  ProvInfo.cbStruct = sizeof(CRYPT_REGISTER_ACTIONID);
596  ProvInfo.sObjectProvider = SoftpubMessage;
601  ProvInfo.sTestPolicyProvider = NullCTRE; /* No diagnostic policy */
602  ProvInfo.sCleanupProvider = SoftpubCleanup;
603 
606 
608  RegisteredOK = FALSE;
610  RegisteredOK = FALSE;
612  RegisteredOK = FALSE;
614  RegisteredOK = FALSE;
615 
616  WINTRUST_Free(DefUsage.pwszDllName);
617 
618  if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
619  RegisteredOK = FALSE;
620 
621  return RegisteredOK;
622 }
623 
624 /***************************************************************************
625  * WINTRUST_RegisterOfficeSignVerify
626  *
627  * Register OFFICESIGN_ACTION_VERIFY actions and usages.
628  *
629  * NOTES
630  * OFFICESIGN_ACTION_VERIFY ({5555C2CD-17FB-11D1-85C4-00C04FC295EE})
631  * is defined in softpub.h
632  */
634 {
635  static GUID ProvGUID = OFFICESIGN_ACTION_VERIFY;
636  CRYPT_REGISTER_ACTIONID ProvInfo;
637 
638  ProvInfo.cbStruct = sizeof(CRYPT_REGISTER_ACTIONID);
640  ProvInfo.sObjectProvider = SoftpubMessage;
645  ProvInfo.sTestPolicyProvider = NullCTRE; /* No diagnostic policy */
647 
648 
649  if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
650  return FALSE;
651 
652  return TRUE;
653 }
654 
655 /***************************************************************************
656  * WINTRUST_RegisterDriverVerify
657  *
658  * Register DRIVER_ACTION_VERIFY actions and usages.
659  *
660  * NOTES
661  * DRIVER_ACTION_VERIFY ({F750E6C3-38EE-11D1-85E5-00C04FC295EE})
662  * is defined in softpub.h
663  */
665 {
666  static GUID ProvGUID = DRIVER_ACTION_VERIFY;
667  CRYPT_REGISTER_ACTIONID ProvInfo;
668 
669  ProvInfo.cbStruct = sizeof(CRYPT_REGISTER_ACTIONID);
671  ProvInfo.sObjectProvider = SoftpubMessage;
676  ProvInfo.sTestPolicyProvider = NullCTRE; /* No diagnostic policy */
678 
679 
680  if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
681  return FALSE;
682 
683  return TRUE;
684 }
685 
686 /***************************************************************************
687  * WINTRUST_RegisterGenChainVerify
688  *
689  * Register WINTRUST_ACTION_GENERIC_CHAIN_VERIFY actions and usages.
690  *
691  * NOTES
692  * WINTRUST_ACTION_GENERIC_CHAIN_VERIFY ({FC451C16-AC75-11D1-B4B8-00C04FB66EA0})
693  * is defined in softpub.h
694  */
696 {
697  static GUID ProvGUID = WINTRUST_ACTION_GENERIC_CHAIN_VERIFY;
698  CRYPT_REGISTER_ACTIONID ProvInfo;
699 
700  ProvInfo.cbStruct = sizeof(CRYPT_REGISTER_ACTIONID);
702  ProvInfo.sObjectProvider = SoftpubMessage;
707  ProvInfo.sTestPolicyProvider = NullCTRE; /* No diagnostic policy */
708  ProvInfo.sCleanupProvider = SoftpubCleanup;
709 
710  if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
711  return FALSE;
712 
713  return TRUE;
714 }
715 
716 /***********************************************************************
717  * WintrustAddDefaultForUsage (WINTRUST.@)
718  *
719  * Write OID and callback functions to the registry.
720  *
721  * PARAMS
722  * pszUsageOID [I] Pointer to a GUID.
723  * psDefUsage [I] Pointer to a structure that specifies the callback functions.
724  *
725  * RETURNS
726  * Success: TRUE.
727  * Failure: FALSE.
728  *
729  * NOTES
730  * WintrustAddDefaultForUsage will only return TRUE or FALSE, no last
731  * error is set, not even when the registry cannot be written to.
732  */
733 BOOL WINAPI WintrustAddDefaultForUsage(const char *pszUsageOID,
734  CRYPT_PROVIDER_REGDEFUSAGE *psDefUsage)
735 {
736  static const WCHAR CBAlloc[] = {'C','a','l','l','b','a','c','k','A','l','l','o','c','F','u','n','c','t','i','o','n', 0};
737  static const WCHAR CBFree[] = {'C','a','l','l','b','a','c','k','F','r','e','e','F','u','n','c','t','i','o','n', 0};
738  LONG Res = ERROR_SUCCESS;
739  LONG WriteUsageError = ERROR_SUCCESS;
740  DWORD Len;
741  WCHAR GuidString[39];
742 
743  TRACE("(%s %p)\n", debugstr_a(pszUsageOID), psDefUsage);
744 
745  /* Some sanity checks. */
746  if (!pszUsageOID ||
747  !psDefUsage ||
748  !psDefUsage->pgActionID ||
749  (psDefUsage->cbStruct != sizeof(CRYPT_PROVIDER_REGDEFUSAGE)))
750  {
752  return FALSE;
753  }
754 
755  if (psDefUsage->pwszDllName)
756  {
757  Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, Dll, psDefUsage->pwszDllName);
758  if (Res != ERROR_SUCCESS) WriteUsageError = Res;
759  }
760  if (psDefUsage->pwszLoadCallbackDataFunctionName)
761  {
762  WCHAR* CallbackW;
763 
764  Len = MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszLoadCallbackDataFunctionName, -1, NULL, 0 );
765  CallbackW = WINTRUST_Alloc( Len * sizeof(WCHAR) );
766  MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszLoadCallbackDataFunctionName, -1, CallbackW, Len );
767 
768  Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, CBAlloc, CallbackW);
769  if (Res != ERROR_SUCCESS) WriteUsageError = Res;
770 
771  WINTRUST_Free(CallbackW);
772  }
773  if (psDefUsage->pwszFreeCallbackDataFunctionName)
774  {
775  WCHAR* CallbackW;
776 
777  Len = MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszFreeCallbackDataFunctionName, -1, NULL, 0 );
778  CallbackW = WINTRUST_Alloc( Len * sizeof(WCHAR) );
779  MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszFreeCallbackDataFunctionName, -1, CallbackW, Len );
780 
781  Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, CBFree, CallbackW);
782  if (Res != ERROR_SUCCESS) WriteUsageError = Res;
783 
784  WINTRUST_Free(CallbackW);
785  }
786 
787  WINTRUST_Guid2Wstr(psDefUsage->pgActionID, GuidString);
788  Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, DefaultId, GuidString);
789  if (Res != ERROR_SUCCESS) WriteUsageError = Res;
790 
791  if (WriteUsageError != ERROR_SUCCESS)
792  return FALSE;
793 
794  return TRUE;
795 }
796 
798 {
799  WCHAR ProvKey[MAX_PATH], DllName[MAX_PATH];
800  char FunctionName[MAX_PATH];
801  HKEY Key;
802  LONG Res = ERROR_SUCCESS;
803  DWORD Size;
804  HMODULE Lib;
805  FARPROC Func = NULL;
806 
807  /* Create the needed key string */
808  ProvKey[0]='\0';
809  lstrcatW(ProvKey, Trust);
810  lstrcatW(ProvKey, FunctionType);
811  lstrcatW(ProvKey, GuidString);
812 
813  Res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, ProvKey, 0, KEY_READ, &Key);
814  if (Res != ERROR_SUCCESS) return NULL;
815 
816  /* Read the $DLL entry */
817  Size = sizeof(DllName);
818  Res = RegQueryValueExW(Key, Dll, NULL, NULL, (LPBYTE)DllName, &Size);
819  if (Res != ERROR_SUCCESS) goto error_close_key;
820 
821  /* Read the $Function entry */
822  Size = sizeof(FunctionName);
823  Res = RegQueryValueExA(Key, "$Function", NULL, NULL, (LPBYTE)FunctionName, &Size);
824  if (Res != ERROR_SUCCESS) goto error_close_key;
825 
826  /* Load the library - there appears to be no way to close a provider, so
827  * just leak the module handle.
828  */
829  Lib = LoadLibraryW(DllName);
830  Func = GetProcAddress(Lib, FunctionName);
831 
832 error_close_key:
833  RegCloseKey(Key);
834 
835  return Func;
836 }
837 
838 /***********************************************************************
839  * WintrustLoadFunctionPointers (WINTRUST.@)
840  */
842  CRYPT_PROVIDER_FUNCTIONS* pPfns )
843 {
844  WCHAR GuidString[39];
845 
846  TRACE("(%s %p)\n", debugstr_guid(pgActionID), pPfns);
847 
848  if (!pPfns) return FALSE;
849  if (!pgActionID)
850  {
852  return FALSE;
853  }
854  if (pPfns->cbStruct != sizeof(CRYPT_PROVIDER_FUNCTIONS)) return FALSE;
855 
856  /* Create this string only once, instead of in the helper function */
857  WINTRUST_Guid2Wstr( pgActionID, GuidString);
858 
859  /* Get the function pointers from the registry, where applicable */
860  pPfns->pfnAlloc = WINTRUST_Alloc;
861  pPfns->pfnFree = WINTRUST_Free;
866  pPfns->psUIpfns = NULL;
875 
876  return TRUE;
877 }
878 
879 /***********************************************************************
880  * WINTRUST_SIPPAddProvider
881  *
882  * Helper for DllRegisterServer.
883  */
884 static BOOL WINTRUST_SIPPAddProvider(GUID* Subject, WCHAR* MagicNumber)
885 {
887  {'C','r','y','p','t','S','I','P','G','e','t','S','i','g','n','e','d','D','a','t','a','M','s','g', 0};
889  {'C','r','y','p','t','S','I','P','P','u','t','S','i','g','n','e','d','D','a','t','a','M','s','g', 0};
891  {'C','r','y','p','t','S','I','P','C','r','e','a','t','e','I','n','d','i','r','e','c','t','D','a','t','a', 0};
893  {'C','r','y','p','t','S','I','P','V','e','r','i','f','y','I','n','d','i','r','e','c','t','D','a','t','a', 0};
895  {'C','r','y','p','t','S','I','P','R','e','m','o','v','e','S','i','g','n','e','d','D','a','t','a','M','s','g', 0};
896  SIP_ADD_NEWPROVIDER NewProv;
897  BOOL Ret;
898 
899  /* Clear and initialize the structure */
900  memset(&NewProv, 0, sizeof(SIP_ADD_NEWPROVIDER));
901  NewProv.cbStruct = sizeof(SIP_ADD_NEWPROVIDER);
903  /* Fill the structure */
904  NewProv.pgSubject = Subject;
906  NewProv.pwszMagicNumber = MagicNumber;
907  NewProv.pwszIsFunctionName = NULL;
913  NewProv.pwszIsFunctionNameFmt2 = NULL;
914  NewProv.pwszGetCapFuncName = NULL;
915 
916  Ret = CryptSIPAddProvider(&NewProv);
917 
919 
920  return Ret;
921 }
922 
923 /***********************************************************************
924  * DllRegisterServer (WINTRUST.@)
925  */
927 {
928  static const CHAR SpcPeImageDataEncode[] = "WVTAsn1SpcPeImageDataEncode";
929  static const CHAR SpcPeImageDataDecode[] = "WVTAsn1SpcPeImageDataDecode";
930  static const CHAR SpcLinkEncode[] = "WVTAsn1SpcLinkEncode";
931  static const CHAR SpcLinkDecode[] = "WVTAsn1SpcLinkDecode";
932  static const CHAR SpcSigInfoEncode[] = "WVTAsn1SpcSigInfoEncode";
933  static const CHAR SpcSigInfoDecode[] = "WVTAsn1SpcSigInfoDecode";
934  static const CHAR SpcIndirectDataContentEncode[] = "WVTAsn1SpcIndirectDataContentEncode";
935  static const CHAR SpcIndirectDataContentDecode[] = "WVTAsn1SpcIndirectDataContentDecode";
936  static const CHAR SpcSpAgencyInfoEncode[] = "WVTAsn1SpcSpAgencyInfoEncode";
937  static const CHAR SpcSpAgencyInfoDecode[] = "WVTAsn1SpcSpAgencyInfoDecode";
938  static const CHAR SpcMinimalCriteriaInfoEncode[] = "WVTAsn1SpcMinimalCriteriaInfoEncode";
939  static const CHAR SpcMinimalCriteriaInfoDecode[] = "WVTAsn1SpcMinimalCriteriaInfoDecode";
940  static const CHAR SpcFinancialCriteriaInfoEncode[] = "WVTAsn1SpcFinancialCriteriaInfoEncode";
941  static const CHAR SpcFinancialCriteriaInfoDecode[] = "WVTAsn1SpcFinancialCriteriaInfoDecode";
942  static const CHAR SpcStatementTypeEncode[] = "WVTAsn1SpcStatementTypeEncode";
943  static const CHAR SpcStatementTypeDecode[] = "WVTAsn1SpcStatementTypeDecode";
944  static const CHAR CatNameValueEncode[] = "WVTAsn1CatNameValueEncode";
945  static const CHAR CatNameValueDecode[] = "WVTAsn1CatNameValueDecode";
946  static const CHAR CatMemberInfoEncode[] = "WVTAsn1CatMemberInfoEncode";
947  static const CHAR CatMemberInfoDecode[] = "WVTAsn1CatMemberInfoDecode";
948  static const CHAR SpcSpOpusInfoEncode[] = "WVTAsn1SpcSpOpusInfoEncode";
949  static const CHAR SpcSpOpusInfoDecode[] = "WVTAsn1SpcSpOpusInfoDecode";
950  static GUID Unknown1 = { 0xDE351A42, 0x8E59, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
951  static GUID Unknown2 = { 0xC689AABA, 0x8E78, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
952  static GUID Unknown3 = { 0xC689AAB8, 0x8E78, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
953  static GUID Unknown4 = { 0xC689AAB9, 0x8E78, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
954  static GUID Unknown5 = { 0xDE351A43, 0x8E59, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
955  static GUID Unknown6 = { 0x9BA61D3F, 0xE73A, 0x11D0, { 0x8C,0xD2,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
956  static WCHAR MagicNumber2[] = {'M','S','C','F', 0};
957  static WCHAR MagicNumber3[] = {'0','x','0','0','0','0','4','5','5','0', 0};
958  static WCHAR CafeBabe[] = {'0','x','c','a','f','e','b','a','b','e', 0};
959 
960  HRESULT CryptRegisterRes = S_OK;
961  HRESULT TrustProviderRes = S_OK;
962  HRESULT SIPAddProviderRes = S_OK;
963  HCRYPTPROV crypt_provider;
964  BOOL ret;
965 
966  TRACE("\n");
967 
968  /* Testing on native shows that when an error is encountered in one of the CryptRegisterOIDFunction calls
969  * the rest of these calls are skipped. Registering is however continued for the trust providers.
970  *
971  * We are not totally in line with native as all decoding functions are registered after all encoding
972  * functions there.
973  */
974 #define WINTRUST_REGISTEROID( oid, encode_funcname, decode_funcname ) \
975  do { \
976  if (!CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_ENCODE_OBJECT_FUNC, oid, SP_POLICY_PROVIDER_DLL_NAME, encode_funcname)) \
977  { \
978  CryptRegisterRes = HRESULT_FROM_WIN32(GetLastError()); \
979  goto add_trust_providers; \
980  } \
981  if (!CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_DECODE_OBJECT_FUNC, oid, SP_POLICY_PROVIDER_DLL_NAME, decode_funcname)) \
982  { \
983  CryptRegisterRes = HRESULT_FROM_WIN32(GetLastError()); \
984  goto add_trust_providers; \
985  } \
986  } while (0)
987 
988  WINTRUST_REGISTEROID(SPC_PE_IMAGE_DATA_OBJID, SpcPeImageDataEncode, SpcPeImageDataDecode);
989  WINTRUST_REGISTEROID(SPC_PE_IMAGE_DATA_STRUCT, SpcPeImageDataEncode, SpcPeImageDataDecode);
990  WINTRUST_REGISTEROID(SPC_CAB_DATA_OBJID, SpcLinkEncode, SpcLinkDecode);
991  WINTRUST_REGISTEROID(SPC_CAB_DATA_STRUCT, SpcLinkEncode, SpcLinkDecode);
992  WINTRUST_REGISTEROID(SPC_JAVA_CLASS_DATA_OBJID, SpcLinkEncode, SpcLinkDecode);
993  WINTRUST_REGISTEROID(SPC_JAVA_CLASS_DATA_STRUCT, SpcLinkEncode, SpcLinkDecode);
994  WINTRUST_REGISTEROID(SPC_LINK_OBJID, SpcLinkEncode, SpcLinkDecode);
995  WINTRUST_REGISTEROID(SPC_LINK_STRUCT, SpcLinkEncode, SpcLinkDecode);
996  WINTRUST_REGISTEROID(SPC_SIGINFO_OBJID, SpcSigInfoEncode, SpcSigInfoDecode);
997  WINTRUST_REGISTEROID(SPC_SIGINFO_STRUCT, SpcSigInfoEncode, SpcSigInfoDecode);
998  WINTRUST_REGISTEROID(SPC_INDIRECT_DATA_OBJID, SpcIndirectDataContentEncode, SpcIndirectDataContentDecode);
999  WINTRUST_REGISTEROID(SPC_INDIRECT_DATA_CONTENT_STRUCT, SpcIndirectDataContentEncode, SpcIndirectDataContentDecode);
1000  WINTRUST_REGISTEROID(SPC_SP_AGENCY_INFO_OBJID, SpcSpAgencyInfoEncode, SpcSpAgencyInfoDecode);
1001  WINTRUST_REGISTEROID(SPC_SP_AGENCY_INFO_STRUCT, SpcSpAgencyInfoEncode, SpcSpAgencyInfoDecode);
1002  WINTRUST_REGISTEROID(SPC_MINIMAL_CRITERIA_OBJID, SpcMinimalCriteriaInfoEncode, SpcMinimalCriteriaInfoDecode);
1003  WINTRUST_REGISTEROID(SPC_MINIMAL_CRITERIA_STRUCT, SpcMinimalCriteriaInfoEncode, SpcMinimalCriteriaInfoDecode);
1004  WINTRUST_REGISTEROID(SPC_FINANCIAL_CRITERIA_OBJID, SpcFinancialCriteriaInfoEncode, SpcFinancialCriteriaInfoDecode);
1005  WINTRUST_REGISTEROID(SPC_FINANCIAL_CRITERIA_STRUCT, SpcFinancialCriteriaInfoEncode, SpcFinancialCriteriaInfoDecode);
1006  WINTRUST_REGISTEROID(SPC_STATEMENT_TYPE_OBJID, SpcStatementTypeEncode, SpcStatementTypeDecode);
1007  WINTRUST_REGISTEROID(SPC_STATEMENT_TYPE_STRUCT, SpcStatementTypeEncode, SpcStatementTypeDecode);
1008  WINTRUST_REGISTEROID(CAT_NAMEVALUE_OBJID, CatNameValueEncode, CatNameValueDecode);
1009  WINTRUST_REGISTEROID(CAT_NAMEVALUE_STRUCT, CatNameValueEncode, CatNameValueDecode);
1010  WINTRUST_REGISTEROID(CAT_MEMBERINFO_OBJID, CatMemberInfoEncode, CatMemberInfoDecode);
1011  WINTRUST_REGISTEROID(CAT_MEMBERINFO_STRUCT, CatMemberInfoEncode, CatMemberInfoDecode);
1012  WINTRUST_REGISTEROID(SPC_SP_OPUS_INFO_OBJID, SpcSpOpusInfoEncode, SpcSpOpusInfoDecode);
1013  WINTRUST_REGISTEROID(SPC_SP_OPUS_INFO_STRUCT, SpcSpOpusInfoEncode, SpcSpOpusInfoDecode);
1014 
1015 #undef WINTRUST_REGISTEROID
1016 
1017 add_trust_providers:
1018 
1019  /* Testing on W2K3 shows:
1020  * All registry writes are tried. If one fails this part will return S_FALSE.
1021  *
1022  * Last error is set to the last error encountered, regardless if the first
1023  * part failed or not.
1024  */
1025 
1026  /* Create the necessary action registry structures */
1028 
1029  /* Register several Trust Provider actions */
1031  TrustProviderRes = S_FALSE;
1033  TrustProviderRes = S_FALSE;
1035  TrustProviderRes = S_FALSE;
1037  TrustProviderRes = S_FALSE;
1039  TrustProviderRes = S_FALSE;
1041  TrustProviderRes = S_FALSE;
1043  TrustProviderRes = S_FALSE;
1045  TrustProviderRes = S_FALSE;
1047  TrustProviderRes = S_FALSE;
1048 
1049  /* Free the registry structures */
1051 
1052  /* Testing on W2K3 shows:
1053  * All registry writes are tried. If one fails this part will return S_FALSE.
1054  *
1055  * Last error is set to the last error encountered, regardless if the previous
1056  * parts failed or not.
1057  */
1058 
1059  if (!WINTRUST_SIPPAddProvider(&Unknown1, NULL))
1060  SIPAddProviderRes = S_FALSE;
1061  if (!WINTRUST_SIPPAddProvider(&Unknown2, MagicNumber2))
1062  SIPAddProviderRes = S_FALSE;
1063  if (!WINTRUST_SIPPAddProvider(&Unknown3, MagicNumber3))
1064  SIPAddProviderRes = S_FALSE;
1065  if (!WINTRUST_SIPPAddProvider(&Unknown4, CafeBabe))
1066  SIPAddProviderRes = S_FALSE;
1067  if (!WINTRUST_SIPPAddProvider(&Unknown5, CafeBabe))
1068  SIPAddProviderRes = S_FALSE;
1069  if (!WINTRUST_SIPPAddProvider(&Unknown6, CafeBabe))
1070  SIPAddProviderRes = S_FALSE;
1071 
1072  /* Native does a CryptSIPRemoveProvider here for {941C2937-1292-11D1-85BE-00C04FC295EE}.
1073  * This SIP Provider is however not found on up-to-date window install and native will
1074  * set the last error to ERROR_FILE_NOT_FOUND.
1075  * Wine has the last error set to ERROR_INVALID_PARAMETER. There shouldn't be an app
1076  * depending on this last error though so there is no need to imitate native to the full extent.
1077  *
1078  * (The ERROR_INVALID_PARAMETER for Wine it totally valid as we (and native) do register
1079  * a trust provider without a diagnostic policy).
1080  */
1081 
1082  /* Create a dummy context to force creation of the MachineGuid registry key. */
1083  ret = CryptAcquireContextW(&crypt_provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
1084  if (ret) CryptReleaseContext(crypt_provider, 0);
1085  else ERR("Failed to acquire cryptographic context: %u\n", GetLastError());
1086 
1087  /* If CryptRegisterRes is not S_OK it will always overrule the return value. */
1088  if (CryptRegisterRes != S_OK)
1089  return CryptRegisterRes;
1090  else if (SIPAddProviderRes == S_OK)
1091  return TrustProviderRes;
1092  else
1093  return SIPAddProviderRes;
1094 }
1095 
1096 /***********************************************************************
1097  * DllUnregisterServer (WINTRUST.@)
1098  */
1100 {
1101  FIXME("stub\n");
1102  return S_OK;
1103 }
1104 
1105 /***********************************************************************
1106  * SoftpubDllRegisterServer (WINTRUST.@)
1107  *
1108  * Registers softpub.dll
1109  *
1110  * PARAMS
1111  *
1112  * RETURNS
1113  * Success: S_OK.
1114  * Failure: S_FALSE. (See also GetLastError()).
1115  *
1116  * NOTES
1117  * DllRegisterServer in softpub.dll will call this function.
1118  * See comments in DllRegisterServer.
1119  */
1121 {
1122  HRESULT TrustProviderRes = S_OK;
1123 
1124  TRACE("\n");
1125 
1126  /* Create the necessary action registry structures */
1128 
1129  /* Register several Trust Provider actions */
1131  TrustProviderRes = S_FALSE;
1133  TrustProviderRes = S_FALSE;
1135  TrustProviderRes = S_FALSE;
1137  TrustProviderRes = S_FALSE;
1139  TrustProviderRes = S_FALSE;
1141  TrustProviderRes = S_FALSE;
1143  TrustProviderRes = S_FALSE;
1145  TrustProviderRes = S_FALSE;
1147  TrustProviderRes = S_FALSE;
1148 
1149  /* Free the registry structures */
1151 
1152  return TrustProviderRes;
1153 }
1154 
1155 /***********************************************************************
1156  * SoftpubDllUnregisterServer (WINTRUST.@)
1157  */
1159 {
1160  FIXME("stub\n");
1161  return S_OK;
1162 }
1163 
1164 /***********************************************************************
1165  * mscat32DllRegisterServer (WINTRUST.@)
1166  */
1168 {
1169  FIXME("stub\n");
1170  return S_OK;
1171 }
1172 
1173 /***********************************************************************
1174  * mscat32DllUnregisterServer (WINTRUST.@)
1175  */
1177 {
1178  FIXME("stub\n");
1179  return S_OK;
1180 }
1181 
1182 /***********************************************************************
1183  * mssip32DllRegisterServer (WINTRUST.@)
1184  */
1186 {
1187  FIXME("stub\n");
1188  return S_OK;
1189 }
1190 
1191 /***********************************************************************
1192  * mssip32DllUnregisterServer (WINTRUST.@)
1193  */
1195 {
1196  FIXME("stub\n");
1197  return S_OK;
1198 }
#define SPC_FINANCIAL_CRITERIA_OBJID
Definition: wintrust.h:495
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
static LONG WINTRUST_WriteProviderToReg(WCHAR *GuidString, const WCHAR *FunctionType, CRYPT_TRUST_REG_ENTRY RegEntry)
Definition: register.c:179
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4041
static PWSTR GuidString
Definition: apphelp.c:91
static const WCHAR DRIVER_CLEANUPPOLICY_FUNCTION[]
Definition: softpub.h:219
static const WCHAR Message[]
Definition: register.c:74
static const WCHAR DefaultId[]
Definition: register.c:82
struct _CRYPT_PROVUI_FUNCS * psUIpfns
Definition: wintrust.h:328
static const WCHAR HTTPS_CERTTRUST_FUNCTION[]
Definition: softpub.h:171
#define TRUE
Definition: types.h:120
static CRYPT_TRUST_REG_ENTRY SoftpubSignature
Definition: register.c:42
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES IN DWORD Unknown3
Definition: conport.c:35
BOOL WINAPI WintrustAddDefaultForUsage(const char *pszUsageOID, CRYPT_PROVIDER_REGDEFUSAGE *psDefUsage)
Definition: register.c:733
static const WCHAR SP_CLEANUPPOLICY_FUNCTION[]
Definition: softpub.h:142
#define ERROR_SUCCESS
Definition: deptool.c:10
BOOL WINAPI CryptSIPVerifyIndirectData(SIP_SUBJECTINFO *pSubjectInfo, SIP_INDIRECT_DATA *pIndirectData)
Definition: sip.c:791
WCHAR * pwszGetFuncName
Definition: mssip.h:152
WCHAR * pwszVerifyFuncName
Definition: mssip.h:155
static CRYPT_TRUST_REG_ENTRY HTTPSCertificateTrust
Definition: register.c:52
WCHAR * pwszDLLName
Definition: wintrust.h:168
PFN_CPD_MEM_ALLOC pfnAlloc
Definition: wintrust.h:315
static const WCHAR SP_GENERIC_CERT_INIT_FUNCTION[]
Definition: softpub.h:33
static const WCHAR SP_OBJTRUST_FUNCTION[]
Definition: softpub.h:134
#define KEY_READ
Definition: nt_native.h:1023
PFN_CPD_ADD_STORE pfnAddStore2Chain
Definition: wintrust.h:317
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define SPC_CAB_DATA_OBJID
Definition: wintrust.h:492
WCHAR * pwszDLLFileName
Definition: mssip.h:147
HRESULT(WINAPI * PFN_PROVIDER_FINALPOLICY_CALL)(struct _CRYPT_PROVIDER_DATA *pProvData)
Definition: wintrust.h:303
static const WCHAR Certificate[]
Definition: register.c:76
#define CP_ACP
Definition: compat.h:99
IN OUT PIRP IN ULONG IN WMIENABLEDISABLECONTROL Function
Definition: wmilib.h:37
unsigned char * LPBYTE
Definition: typedefs.h:52
char CHAR
Definition: xmlstorage.h:175
HRESULT(WINAPI * PFN_PROVIDER_TESTFINALPOLICY_CALL)(struct _CRYPT_PROVIDER_DATA *pProvData)
Definition: wintrust.h:305
static CRYPT_TRUST_REG_ENTRY OfficeCleanupPolicy
Definition: register.c:56
#define SPC_LINK_STRUCT
Definition: wintrust.h:506
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1240
static CRYPT_TRUST_REG_ENTRY GenericChainFinalProv
Definition: register.c:63
#define SPC_SP_AGENCY_INFO_OBJID
Definition: wintrust.h:482
static LONG WINTRUST_WriteSingleUsageEntry(LPCSTR OID, const WCHAR *Value, WCHAR *Data)
Definition: register.c:373
PFN_PROVIDER_CLEANUP_CALL pfnCleanupPolicy
Definition: wintrust.h:329
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES IN DWORD IN DWORD IN DWORD IN DWORD Unknown6
Definition: conport.c:35
static BOOL WINTRUST_RegisterGenCertVerify(void)
Definition: register.c:521
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
static const WCHAR FinalPolicy[]
Definition: register.c:78
static BOOL WINTRUST_RegisterPublishedSoftwareNoBadUi(void)
Definition: register.c:491
#define SPC_MINIMAL_CRITERIA_STRUCT
Definition: wintrust.h:502
HRESULT(WINAPI * PFN_PROVIDER_CERTTRUST_CALL)(struct _CRYPT_PROVIDER_DATA *pProvData)
Definition: wintrust.h:301
#define CAT_MEMBERINFO_STRUCT
Definition: wintrust.h:513
BOOL WINAPI WINTRUST_AddSgnr(CRYPT_PROVIDER_DATA *data, BOOL fCounterSigner, DWORD idxSigner, CRYPT_PROVIDER_SGNR *sgnr)
#define SPC_LINK_OBJID
Definition: wintrust.h:496
#define szOID_PKIX_KP_SERVER_AUTH
Definition: wincrypt.h:3292
#define WIN_SPUB_ACTION_PUBLISHED_SOFTWARE
Definition: wintrust.h:661
static BOOL WINTRUST_RegisterGenVerifyV2(void)
Definition: register.c:420
#define lstrlenW
Definition: compat.h:407
HRESULT WINAPI SoftpubDllRegisterServer(void)
Definition: register.c:1120
#define szOID_PKIX_KP_CODE_SIGNING
Definition: wincrypt.h:3294
static const WCHAR DRIVER_FINALPOLPROV_FUNCTION[]
Definition: softpub.h:217
static const WCHAR OFFICE_POLICY_PROVIDER_DLL_NAME[]
Definition: softpub.h:192
DWORD DWORD
Definition: winlogon.h:84
static const WCHAR SP_TESTDUMPPOLICY_FUNCTION_TEST[]
Definition: softpub.h:155
static const WCHAR Trust[]
Definition: register.c:67
WINE_DEFAULT_DEBUG_CHANNEL(wintrust)
HRESULT WINAPI DllRegisterServer(void)
Definition: register.c:926
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:1094
static CRYPT_TRUST_REG_ENTRY DriverFinalPolicy
Definition: register.c:59
#define CAT_NAMEVALUE_OBJID
Definition: wintrust.h:498
BOOL WINAPI CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
Definition: crypt.c:358
#define SPC_SP_OPUS_INFO_OBJID
Definition: wintrust.h:484
static const WCHAR Dll[]
Definition: register.c:83
CRYPT_TRUST_REG_ENTRY sFinalPolicyProvider
Definition: wintrust.h:180
BOOL WINAPI WINTRUST_AddCert(CRYPT_PROVIDER_DATA *data, DWORD idxSigner, BOOL fCounterSigner, DWORD idxCounterSigner, PCCERT_CONTEXT pCert2Add)
#define WINTRUST_ACTION_GENERIC_VERIFY_V2
Definition: softpub.h:108
#define SPC_CAB_DATA_STRUCT
Definition: wintrust.h:509
BOOL WINAPI CryptSIPPutSignedDataMsg(SIP_SUBJECTINFO *pSubjectInfo, DWORD pdwEncodingType, DWORD *pdwIndex, DWORD cbSignedDataMsg, BYTE *pbSignedDataMsg)
Definition: sip.c:755
static const WCHAR CertCheck[]
Definition: register.c:77
static BOOL WINTRUST_RegisterTrustProviderTest(void)
Definition: register.c:551
CRYPT_TRUST_REG_ENTRY sTestPolicyProvider
Definition: wintrust.h:181
static CRYPT_TRUST_REG_ENTRY SoftpubInitialization
Definition: register.c:40
HRESULT WINAPI mscat32DllUnregisterServer(void)
Definition: register.c:1176
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
static CRYPT_TRUST_REG_ENTRY OfficeInitializePolicy
Definition: register.c:55
HRESULT WINAPI mssip32DllRegisterServer(void)
Definition: register.c:1185
GUID * pgSubject
Definition: mssip.h:145
#define FALSE
Definition: types.h:117
WCHAR * pwszPutFuncName
Definition: mssip.h:153
CRYPT_TRUST_REG_ENTRY sCleanupProvider
Definition: wintrust.h:182
HRESULT WINAPI DllUnregisterServer(void)
Definition: register.c:1099
static const WCHAR DiagnosticPolicy[]
Definition: register.c:79
long LONG
Definition: pedump.c:60
#define CAT_NAMEVALUE_STRUCT
Definition: wintrust.h:512
PRTL_UNICODE_STRING_BUFFER PULONG PULONG Unknown4
#define SPC_SP_OPUS_INFO_STRUCT
Definition: wintrust.h:508
PFN_CPD_ADD_CERT pfnAddCert2Chain
Definition: wintrust.h:319
#define WINTRUST_ACTION_TRUSTPROVIDER_TEST
Definition: softpub.h:146
static const WCHAR HTTPS_FINALPOLICY_FUNCTION[]
Definition: softpub.h:173
static void WINTRUST_Guid2Wstr(const GUID *pgActionID, WCHAR *GuidString)
Definition: register.c:162
#define FIXME(fmt,...)
Definition: debug.h:110
static BOOL WINTRUST_RegisterOfficeSignVerify(void)
Definition: register.c:633
#define S_FALSE
Definition: winerror.h:2357
static CRYPT_TRUST_REG_ENTRY DriverInitializePolicy
Definition: register.c:58
BOOL WINAPI CryptSIPGetSignedDataMsg(SIP_SUBJECTINFO *pSubjectInfo, DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg, BYTE *pbSignedDataMsg)
Definition: sip.c:736
PFN_PROVIDER_CERTCHKPOLICY_CALL pfnCertCheckPolicy
Definition: wintrust.h:326
#define LoadLibraryW(x)
Definition: compat.h:404
smooth NULL
Definition: ftsmooth.c:416
static CRYPT_TRUST_REG_ENTRY GenericChainCertificateTrust
Definition: register.c:62
#define SPC_SP_AGENCY_INFO_STRUCT
Definition: wintrust.h:501
#define WINTRUST_FREEREGENTRY(action)
static const WCHAR WT_PROVIDER_CERTTRUST_FUNCTION[]
Definition: wintrust.h:460
const char * LPCSTR
Definition: xmlstorage.h:183
#define debugstr_guid
Definition: kernel32.h:35
static const WCHAR SP_SIGTRUST_FUNCTION[]
Definition: softpub.h:136
static const WCHAR SP_POLICY_PROVIDER_DLL_NAME[]
Definition: softpub.h:104
void WINAPI WINTRUST_Free(void *p)
Definition: wintrust_main.c:56
#define szOID_SGC_NETSCAPE
Definition: wincrypt.h:3214
static FARPROC WINTRUST_ReadProviderFromReg(WCHAR *GuidString, const WCHAR *FunctionType)
Definition: register.c:797
UINTN Size
Definition: acefiex.h:555
#define SPC_STATEMENT_TYPE_OBJID
Definition: wintrust.h:483
static const WCHAR GENERIC_CHAIN_CERTTRUST_FUNCTION[]
Definition: softpub.h:51
#define WINTRUST_INITREGENTRY(action, dllname, functionname)
static const WCHAR DRIVER_INITPROV_FUNCTION[]
Definition: softpub.h:215
#define KEY_WRITE
Definition: nt_native.h:1031
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:4917
#define SPC_PE_IMAGE_DATA_OBJID
Definition: wintrust.h:486
static void WINTRUST_RemoveProviderFromReg(WCHAR *GuidString, const WCHAR *FunctionType)
Definition: register.c:304
static const WCHAR SP_FINALPOLICY_FUNCTION[]
Definition: softpub.h:140
#define TRACE(s)
Definition: solgame.cpp:4
void *WINAPI WINTRUST_Alloc(DWORD cb)
Definition: wintrust_main.c:45
unsigned int BOOL
Definition: ntddk_ex.h:94
static const WCHAR SP_CHKCERT_FUNCTION[]
Definition: softpub.h:138
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
Registry entry.
Definition: regfs.h:30
#define debugstr_a
Definition: kernel32.h:31
PFN_CPD_MEM_FREE pfnFree
Definition: wintrust.h:316
char * pwszFreeCallbackDataFunctionName
Definition: wintrust.h:191
LONG HRESULT
Definition: typedefs.h:77
HANDLE HKEY
Definition: registry.h:24
BOOL WINAPI CryptSIPAddProvider(SIP_ADD_NEWPROVIDER *psNewProv)
Definition: sip.c:206
HRESULT(WINAPI * PFN_PROVIDER_INIT_CALL)(struct _CRYPT_PROVIDER_DATA *pProvData)
Definition: wintrust.h:295
#define MAX_PATH
Definition: compat.h:26
static const WCHAR Signature[]
Definition: register.c:75
HRESULT(WINAPI * PFN_PROVIDER_CLEANUP_CALL)(struct _CRYPT_PROVIDER_DATA *pProvData)
Definition: wintrust.h:307
void(* Func)(int)
static CRYPT_TRUST_REG_ENTRY SoftpubCertificate
Definition: register.c:43
#define HTTPSPROV_ACTION
Definition: softpub.h:159
PFN_CPD_ADD_PRIVDATA pfnAddPrivData2Chain
Definition: wintrust.h:320
#define WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI
Definition: register.c:480
#define Len
Definition: deflate.h:82
static const WCHAR OFFICE_CLEANUPPOLICY_FUNCTION[]
Definition: softpub.h:196
#define SetLastError(x)
Definition: compat.h:409
static BOOL WINTRUST_RegisterPublishedSoftware(void)
Definition: register.c:459
static CRYPT_TRUST_REG_ENTRY SoftpubDefCertInit
Definition: register.c:48
int(* FARPROC)()
Definition: compat.h:28
struct _CRYPT_PROVIDER_REGDEFUSAGE CRYPT_PROVIDER_REGDEFUSAGE
static BOOL WINTRUST_SIPPAddProvider(GUID *Subject, WCHAR *MagicNumber)
Definition: register.c:884
BOOL WINAPI WintrustRemoveActionID(GUID *pgActionID)
Definition: register.c:337
PFN_PROVIDER_OBJTRUST_CALL pfnObjectTrust
Definition: wintrust.h:322
int ret
static CRYPT_TRUST_REG_ENTRY SoftpubCertCheck
Definition: register.c:44
BOOL WINAPI CryptSIPRemoveSignedDataMsg(SIP_SUBJECTINFO *pSubjectInfo, DWORD dwIndex)
Definition: sip.c:774
static CRYPT_TRUST_REG_ENTRY SoftpubCleanup
Definition: register.c:46
#define WINTRUST_ACTION_GENERIC_CERT_VERIFY
Definition: softpub.h:24
static const WCHAR GENERIC_CHAIN_FINALPOLICY_FUNCTION[]
Definition: softpub.h:49
BOOL WINAPI WintrustLoadFunctionPointers(GUID *pgActionID, CRYPT_PROVIDER_FUNCTIONS *pPfns)
Definition: register.c:841
static CRYPT_TRUST_REG_ENTRY SoftpubMessage
Definition: register.c:41
#define SPC_STATEMENT_TYPE_STRUCT
Definition: wintrust.h:507
static const WCHAR OFFICE_INITPROV_FUNCTION[]
Definition: softpub.h:194
static const WCHAR Cleanup[]
Definition: register.c:80
PFN_CPD_ADD_SGNR pfnAddSgnr2Chain
Definition: wintrust.h:318
static void WINTRUST_InitRegStructs(void)
Definition: register.c:91
#define WINAPI
Definition: msvc.h:20
UINTN UINT8 Value
Definition: acefiex.h:751
#define SPC_INDIRECT_DATA_CONTENT_STRUCT
Definition: wintrust.h:504
#define SPC_MINIMAL_CRITERIA_OBJID
Definition: wintrust.h:494
BOOL WINAPI CryptSIPCreateIndirectData(SIP_SUBJECTINFO *pSubjectInfo, DWORD *pcbIndirectData, SIP_INDIRECT_DATA *pIndirectData)
Definition: sip.c:714
#define DRIVER_ACTION_VERIFY
Definition: softpub.h:200
WCHAR * pwszIsFunctionNameFmt2
Definition: mssip.h:158
unsigned char BYTE
Definition: ntddk_ex.h:96
struct _CRYPT_REGISTER_ACTIONID CRYPT_REGISTER_ACTIONID
CRYPT_TRUST_REG_ENTRY sCertificateProvider
Definition: wintrust.h:178
static const WCHAR SP_INIT_FUNCTION[]
Definition: softpub.h:132
#define CRYPT_VERIFYCONTEXT
Definition: wincrypt.h:2069
PFN_PROVIDER_TESTFINALPOLICY_CALL pfnTestFinalPolicy
Definition: wintrust.h:327
BOOL WINAPI WINTRUST_AddStore(CRYPT_PROVIDER_DATA *data, HCERTSTORE store)
#define ERR(fmt,...)
Definition: debug.h:109
static BOOL WINTRUST_RegisterGenChainVerify(void)
Definition: register.c:695
HRESULT WINAPI SoftpubDllUnregisterServer(void)
Definition: register.c:1158
#define S_OK
Definition: intsafe.h:59
BOOL(WINAPI * PFN_PROVIDER_CERTCHKPOLICY_CALL)(struct _CRYPT_PROVIDER_DATA *pProvData, DWORD idxSigner, BOOL fCounterSignerChain, DWORD idxCounterSigner)
Definition: wintrust.h:309
static CRYPT_TRUST_REG_ENTRY HTTPSFinalProv
Definition: register.c:53
CRYPT_TRUST_REG_ENTRY sInitProvider
Definition: wintrust.h:175
static BOOL WINTRUST_RegisterDriverVerify(void)
Definition: register.c:664
static const CRYPT_TRUST_REG_ENTRY NullCTRE
Definition: register.c:65
#define lstrcpyW
Definition: compat.h:406
PFN_PROVIDER_INIT_CALL pfnInitialize
Definition: wintrust.h:321
#define WT_ADD_ACTION_ID_RET_RESULT_FLAG
Definition: wintrust.h:448
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
WCHAR * pwszGetCapFuncName
Definition: mssip.h:161
static const WCHAR Initialization[]
Definition: register.c:73
BOOL WINAPI WINTRUST_AddPrivData(CRYPT_PROVIDER_DATA *data, CRYPT_PROVIDER_PRIVDATA *pPrivData2Add)
static BOOL WINTRUST_RegisterHttpsProv(void)
Definition: register.c:581
PFN_PROVIDER_SIGTRUST_CALL pfnSignatureTrust
Definition: wintrust.h:323
#define SPC_SIGINFO_OBJID
Definition: wintrust.h:497
HRESULT WINAPI mscat32DllRegisterServer(void)
Definition: register.c:1167
#define CAT_MEMBERINFO_OBJID
Definition: wintrust.h:499
#define MultiByteToWideChar
Definition: compat.h:100
HANDLE HMODULE
Definition: typedefs.h:75
BOOL WINAPI WintrustAddActionID(GUID *pgActionID, DWORD fdwFlags, CRYPT_REGISTER_ACTIONID *psProvInfo)
Definition: register.c:238
static CRYPT_TRUST_REG_ENTRY SoftpubDumpStructure
Definition: register.c:50
Definition: wintrust.h:165
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, ULONG_PTR dwFlags)
Definition: crypt.c:651
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char UINT32 const char UINT32 const char * FunctionName
Definition: acpixf.h:1256
static void WINTRUST_FreeRegStructs(void)
Definition: register.c:128
WCHAR * pwszFunctionName
Definition: wintrust.h:169
CRYPT_TRUST_REG_ENTRY sSignatureProvider
Definition: wintrust.h:177
#define SPC_FINANCIAL_CRITERIA_STRUCT
Definition: wintrust.h:503
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
HRESULT(WINAPI * PFN_PROVIDER_OBJTRUST_CALL)(struct _CRYPT_PROVIDER_DATA *pProvData)
Definition: wintrust.h:297
#define SPC_INDIRECT_DATA_OBJID
Definition: wintrust.h:481
#define GetProcAddress(x, y)
Definition: compat.h:410
WCHAR * pwszRemoveFuncName
Definition: mssip.h:156
#define szOID_SERVER_GATED_CRYPTO
Definition: wincrypt.h:3211
#define SPC_SIGINFO_STRUCT
Definition: wintrust.h:511
PFN_PROVIDER_CERTTRUST_CALL pfnCertificateTrust
Definition: wintrust.h:324
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
CRYPT_TRUST_REG_ENTRY sObjectProvider
Definition: wintrust.h:176
#define SPC_PE_IMAGE_DATA_STRUCT
Definition: wintrust.h:505
static CRYPT_TRUST_REG_ENTRY SoftpubFinalPolicy
Definition: register.c:45
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES IN DWORD IN DWORD IN DWORD Unknown5
Definition: conport.c:35
CRYPT_TRUST_REG_ENTRY sCertificatePolicyProvider
Definition: wintrust.h:179
#define memset(x, y, z)
Definition: compat.h:39
WCHAR * pwszCreateFuncName
Definition: mssip.h:154
PFN_PROVIDER_FINALPOLICY_CALL pfnFinalPolicy
Definition: wintrust.h:325
#define szOID_PKIX_KP_CLIENT_AUTH
Definition: wincrypt.h:3293
#define SPC_JAVA_CLASS_DATA_OBJID
Definition: wintrust.h:489
WCHAR * pwszMagicNumber
Definition: mssip.h:148
#define OFFICESIGN_ACTION_VERIFY
Definition: softpub.h:177
#define SPC_JAVA_CLASS_DATA_STRUCT
Definition: wintrust.h:510
#define WINTRUST_REGISTEROID(oid, encode_funcname, decode_funcname)
struct SIP_ADD_NEWPROVIDER_ SIP_ADD_NEWPROVIDER
static CRYPT_TRUST_REG_ENTRY DriverCleanupPolicy
Definition: register.c:60
ACPI_EFI_INPUT_KEY * Key
Definition: acefiex.h:303
#define PROV_RSA_FULL
Definition: wincrypt.h:2039
#define WINTRUST_ACTION_GENERIC_CHAIN_VERIFY
Definition: softpub.h:37
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
HRESULT(WINAPI * PFN_PROVIDER_SIGTRUST_CALL)(struct _CRYPT_PROVIDER_DATA *pProvData)
Definition: wintrust.h:299
char * pwszLoadCallbackDataFunctionName
Definition: wintrust.h:190
#define REG_SZ
Definition: layer.c:22
HRESULT WINAPI mssip32DllUnregisterServer(void)
Definition: register.c:1194
WCHAR * pwszIsFunctionName
Definition: mssip.h:150