dlls/wintrust/register.c

   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
  30 #include "guiddef.h"
  31 #include "wintrust.h"
  32 #include "softpub.h"
  33
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(wintrust);
  37
  38 static CRYPT_TRUST_REG_ENTRY SoftpubInitialization;
  39 static CRYPT_TRUST_REG_ENTRY SoftpubMessage;
  40 static CRYPT_TRUST_REG_ENTRY SoftpubSignature;
  41 static CRYPT_TRUST_REG_ENTRY SoftpubCertficate;
  42 static CRYPT_TRUST_REG_ENTRY SoftpubCertCheck;
  43 static CRYPT_TRUST_REG_ENTRY SoftpubFinalPolicy;
  44 static CRYPT_TRUST_REG_ENTRY SoftpubCleanup;
  45
  46 static CRYPT_TRUST_REG_ENTRY SoftpubDefCertInit;
  47
  48 static CRYPT_TRUST_REG_ENTRY SoftpubDumpStructure;
  49
  50 static CRYPT_TRUST_REG_ENTRY HTTPSCertificateTrust;
  51 static CRYPT_TRUST_REG_ENTRY HTTPSFinalProv;
  52
  53 static CRYPT_TRUST_REG_ENTRY OfficeInitializePolicy;
  54 static CRYPT_TRUST_REG_ENTRY OfficeCleanupPolicy;
  55
  56 static CRYPT_TRUST_REG_ENTRY DriverInitializePolicy;
  57 static CRYPT_TRUST_REG_ENTRY DriverFinalPolicy;
  58 static CRYPT_TRUST_REG_ENTRY DriverCleanupPolicy;
  59
  60 static CRYPT_TRUST_REG_ENTRY GenericChainCertificateTrust;
  61 static CRYPT_TRUST_REG_ENTRY GenericChainFinalProv;
  62
  63 static const WCHAR Trust[]            = {'S','o','f','t','w','a','r','e','\\',
  64                                          'M','i','c','r','o','s','o','f','t','\\',
  65                                          'C','r','y','p','t','o','g','r','a','p','h','y','\\',
  66                                          'P','r','o','v','i','d','e','r','s','\\',
  67                                          'T','r','u','s','t','\\', 0 };
  68
  69 static const WCHAR Initialization[]   = {'I','n','i','t','i','a','l','i','z','a','t','i','o','n','\\', 0};
  70 static const WCHAR Message[]          = {'M','e','s','s','a','g','e','\\', 0};
  71 static const WCHAR Signature[]        = {'S','i','g','n','a','t','u','r','e','\\', 0};
  72 static const WCHAR Certificate[]      = {'C','e','r','t','i','f','i','c','a','t','e','\\', 0};
  73 static const WCHAR CertCheck[]        = {'C','e','r','t','C','h','e','c','k','\\', 0};
  74 static const WCHAR FinalPolicy[]      = {'F','i','n','a','l','P','o','l','i','c','y','\\', 0};
  75 static const WCHAR DiagnosticPolicy[] = {'D','i','a','g','n','o','s','t','i','c','P','o','l','i','c','y','\\', 0};
  76 static const WCHAR Cleanup[]          = {'C','l','e','a','n','u','p','\\', 0};
  77
  78 static const WCHAR DefaultId[]        = {'D','e','f','a','u','l','t','I','d', 0};
  79 static const WCHAR Dll[]              = {'$','D','L','L', 0};
  80
  81 /***********************************************************************
  82  *              WINTRUST_InitRegStructs
  83  *
  84  * Helper function to allocate and initialize the members of the
  85  * CRYPT_TRUST_REG_ENTRY structs.
  86  */
  87 static void WINTRUST_InitRegStructs(void)
  88 {
  89 #define WINTRUST_INITREGENTRY( action, dllname, functionname ) \
  90     action.cbStruct = sizeof(CRYPT_TRUST_REG_ENTRY); \
  91     action.pwszDLLName = HeapAlloc(GetProcessHeap(), 0, sizeof(dllname)); \
  92     lstrcpyW(action.pwszDLLName, dllname); \
  93     action.pwszFunctionName = HeapAlloc(GetProcessHeap(), 0, sizeof(functionname)); \
  94     lstrcpyW(action.pwszFunctionName, functionname);
  95
  96     WINTRUST_INITREGENTRY(SoftpubInitialization, SP_POLICY_PROVIDER_DLL_NAME, SP_INIT_FUNCTION)
  97     WINTRUST_INITREGENTRY(SoftpubMessage, SP_POLICY_PROVIDER_DLL_NAME, SP_OBJTRUST_FUNCTION)
  98     WINTRUST_INITREGENTRY(SoftpubSignature, SP_POLICY_PROVIDER_DLL_NAME, SP_SIGTRUST_FUNCTION)
  99     WINTRUST_INITREGENTRY(SoftpubCertficate, SP_POLICY_PROVIDER_DLL_NAME, WT_PROVIDER_CERTTRUST_FUNCTION)
 100     WINTRUST_INITREGENTRY(SoftpubCertCheck, SP_POLICY_PROVIDER_DLL_NAME, SP_CHKCERT_FUNCTION)
 101     WINTRUST_INITREGENTRY(SoftpubFinalPolicy, SP_POLICY_PROVIDER_DLL_NAME, SP_FINALPOLICY_FUNCTION)
 102     WINTRUST_INITREGENTRY(SoftpubCleanup, SP_POLICY_PROVIDER_DLL_NAME, SP_CLEANUPPOLICY_FUNCTION)
 103     WINTRUST_INITREGENTRY(SoftpubDefCertInit, SP_POLICY_PROVIDER_DLL_NAME, SP_GENERIC_CERT_INIT_FUNCTION)
 104     WINTRUST_INITREGENTRY(SoftpubDumpStructure, SP_POLICY_PROVIDER_DLL_NAME, SP_TESTDUMPPOLICY_FUNCTION_TEST)
 105     WINTRUST_INITREGENTRY(HTTPSCertificateTrust, SP_POLICY_PROVIDER_DLL_NAME, HTTPS_CERTTRUST_FUNCTION)
 106     WINTRUST_INITREGENTRY(HTTPSFinalProv, SP_POLICY_PROVIDER_DLL_NAME, HTTPS_FINALPOLICY_FUNCTION)
 107     WINTRUST_INITREGENTRY(OfficeInitializePolicy, OFFICE_POLICY_PROVIDER_DLL_NAME, OFFICE_INITPROV_FUNCTION)
 108     WINTRUST_INITREGENTRY(OfficeCleanupPolicy, OFFICE_POLICY_PROVIDER_DLL_NAME, OFFICE_CLEANUPPOLICY_FUNCTION)
 109     WINTRUST_INITREGENTRY(DriverInitializePolicy, SP_POLICY_PROVIDER_DLL_NAME, DRIVER_INITPROV_FUNCTION)
 110     WINTRUST_INITREGENTRY(DriverFinalPolicy, SP_POLICY_PROVIDER_DLL_NAME, DRIVER_FINALPOLPROV_FUNCTION)
 111     WINTRUST_INITREGENTRY(DriverCleanupPolicy, SP_POLICY_PROVIDER_DLL_NAME, DRIVER_CLEANUPPOLICY_FUNCTION)
 112     WINTRUST_INITREGENTRY(GenericChainCertificateTrust, SP_POLICY_PROVIDER_DLL_NAME, GENERIC_CHAIN_CERTTRUST_FUNCTION)
 113     WINTRUST_INITREGENTRY(GenericChainFinalProv, SP_POLICY_PROVIDER_DLL_NAME, GENERIC_CHAIN_FINALPOLICY_FUNCTION)
 114
 115 #undef WINTRUST_INITREGENTRY
 116 }
 117
 118 /***********************************************************************
 119  *              WINTRUST_FreeRegStructs
 120  *
 121  * Helper function to free 2 members of the CRYPT_TRUST_REG_ENTRY
 122  * structs.
 123  */
 124 static void WINTRUST_FreeRegStructs(void)
 125 {
 126 #define WINTRUST_FREEREGENTRY( action ) \
 127     HeapFree(GetProcessHeap(), 0, action.pwszDLLName); \
 128     HeapFree(GetProcessHeap(), 0, action.pwszFunctionName);
 129
 130     WINTRUST_FREEREGENTRY(SoftpubInitialization);
 131     WINTRUST_FREEREGENTRY(SoftpubMessage);
 132     WINTRUST_FREEREGENTRY(SoftpubSignature);
 133     WINTRUST_FREEREGENTRY(SoftpubCertficate);
 134     WINTRUST_FREEREGENTRY(SoftpubCertCheck);
 135     WINTRUST_FREEREGENTRY(SoftpubFinalPolicy);
 136     WINTRUST_FREEREGENTRY(SoftpubCleanup);
 137     WINTRUST_FREEREGENTRY(SoftpubDefCertInit);
 138     WINTRUST_FREEREGENTRY(SoftpubDumpStructure);
 139     WINTRUST_FREEREGENTRY(HTTPSCertificateTrust);
 140     WINTRUST_FREEREGENTRY(HTTPSFinalProv);
 141     WINTRUST_FREEREGENTRY(OfficeInitializePolicy);
 142     WINTRUST_FREEREGENTRY(OfficeCleanupPolicy);
 143     WINTRUST_FREEREGENTRY(DriverInitializePolicy);
 144     WINTRUST_FREEREGENTRY(DriverFinalPolicy);
 145     WINTRUST_FREEREGENTRY(DriverCleanupPolicy);
 146     WINTRUST_FREEREGENTRY(GenericChainCertificateTrust);
 147     WINTRUST_FREEREGENTRY(GenericChainFinalProv);
 148
 149 #undef WINTRUST_FREEREGENTRY
 150 }
 151
 152 /***********************************************************************
 153  *              WINTRUST_guid2wstr
 154  *
 155  * Create a wide-string from a GUID
 156  *
 157  */
 158 static void WINTRUST_Guid2Wstr(const GUID* pgActionID, WCHAR* GuidString)
 159 {
 160     static const WCHAR wszFormat[] = {'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
 161                                       '%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
 162                                       'X','%','0','2','X','%','0','2','X','}', 0};
 163
 164     wsprintfW(GuidString, wszFormat, pgActionID->Data1, pgActionID->Data2, pgActionID->Data3,
 165         pgActionID->Data4[0], pgActionID->Data4[1], pgActionID->Data4[2], pgActionID->Data4[3],
 166         pgActionID->Data4[4], pgActionID->Data4[5], pgActionID->Data4[6], pgActionID->Data4[7]);
 167 }
 168
 169 /***********************************************************************
 170  *              WINTRUST_WriteProviderToReg
 171  *
 172  * Helper function for WintrustAddActionID
 173  *
 174  */
 175 static LONG WINTRUST_WriteProviderToReg(WCHAR* GuidString,
 176                                         const WCHAR* FunctionType,
 177                                         CRYPT_TRUST_REG_ENTRY RegEntry)
 178 {
 179     static const WCHAR Function[] = {'$','F','u','n','c','t','i','o','n', 0};
 180     WCHAR ProvKey[MAX_PATH];
 181     HKEY Key;
 182     LONG Res = ERROR_SUCCESS;
 183
 184     /* Create the needed key string */
 185     ProvKey[0]='\0';
 186     lstrcatW(ProvKey, Trust);
 187     lstrcatW(ProvKey, FunctionType);
 188     lstrcatW(ProvKey, GuidString);
 189
 190     if (!RegEntry.pwszDLLName || !RegEntry.pwszFunctionName)
 191         return ERROR_INVALID_PARAMETER;
 192
 193     Res = RegCreateKeyExW(HKEY_LOCAL_MACHINE, ProvKey, 0, NULL, 0, KEY_WRITE, NULL, &Key, NULL);
 194     if (Res != ERROR_SUCCESS) goto error_close_key;
 195
 196     /* Create the $DLL entry */
 197     Res = RegSetValueExW(Key, Dll, 0, REG_SZ, (BYTE*)RegEntry.pwszDLLName,
 198         (lstrlenW(RegEntry.pwszDLLName) + 1)*sizeof(WCHAR));
 199     if (Res != ERROR_SUCCESS) goto error_close_key;
 200
 201     /* Create the $Function entry */
 202     Res = RegSetValueExW(Key, Function, 0, REG_SZ, (BYTE*)RegEntry.pwszFunctionName,
 203         (lstrlenW(RegEntry.pwszFunctionName) + 1)*sizeof(WCHAR));
 204
 205 error_close_key:
 206     RegCloseKey(Key);
 207
 208     return Res;
 209 }
 210
 211 /***********************************************************************
 212  *              WintrustAddActionID (WINTRUST.@)
 213  *
 214  * Add the definitions of the actions a Trust provider can perform to
 215  * the registry.
 216  *
 217  * PARAMS
 218  *   pgActionID [I] Pointer to a GUID for the Trust provider.
 219  *   fdwFlags   [I] Flag to indicate whether registry errors are passed on.
 220  *   psProvInfo [I] Pointer to a structure with information about DLL
 221  *                  name and functions.
 222  *
 223  * RETURNS
 224  *   Success: TRUE.
 225  *   Failure: FALSE. (Use GetLastError() for more information)
 226  *
 227  * NOTES
 228  *   Adding definitions is basically only adding relevant information
 229  *   to the registry. No verification takes place whether a DLL or it's
 230  *   entrypoints exist.
 231  *   Information in the registry will always be overwritten.
 232  *
 233  */
 234 BOOL WINAPI WintrustAddActionID( GUID* pgActionID, DWORD fdwFlags,
 235                                  CRYPT_REGISTER_ACTIONID* psProvInfo)
 236 {
 237     WCHAR GuidString[39];
 238     LONG Res;
 239     LONG WriteActionError = ERROR_SUCCESS;
 240
 241     TRACE("%p %lx %p\n", debugstr_guid(pgActionID), fdwFlags, psProvInfo);
 242
 243     /* Some sanity checks.
 244      * We use the W2K3 last error as it makes more sense (W2K leaves the last error
 245      * as is).
 246      */
 247     if (!pgActionID ||
 248         !psProvInfo ||
 249         (psProvInfo->cbStruct != sizeof(CRYPT_REGISTER_ACTIONID)))
 250     {
 251         SetLastError(ERROR_INVALID_PARAMETER);
 252         return FALSE;
 253     }
 254
 255     /* Create this string only once, instead of in the helper function */
 256     WINTRUST_Guid2Wstr( pgActionID, GuidString);
 257
 258     /* Write the information to the registry */
 259     Res = WINTRUST_WriteProviderToReg(GuidString, Initialization  , psProvInfo->sInitProvider);
 260     if (Res != ERROR_SUCCESS) WriteActionError = Res;
 261     Res = WINTRUST_WriteProviderToReg(GuidString, Message         , psProvInfo->sObjectProvider);
 262     if (Res != ERROR_SUCCESS) WriteActionError = Res;
 263     Res = WINTRUST_WriteProviderToReg(GuidString, Signature       , psProvInfo->sSignatureProvider);
 264     if (Res != ERROR_SUCCESS) WriteActionError = Res;
 265     Res = WINTRUST_WriteProviderToReg(GuidString, Certificate     , psProvInfo->sCertificateProvider);
 266     if (Res != ERROR_SUCCESS) WriteActionError = Res;
 267     Res = WINTRUST_WriteProviderToReg(GuidString, CertCheck       , psProvInfo->sCertificatePolicyProvider);
 268     if (Res != ERROR_SUCCESS) WriteActionError = Res;
 269     Res = WINTRUST_WriteProviderToReg(GuidString, FinalPolicy     , psProvInfo->sFinalPolicyProvider);
 270     if (Res != ERROR_SUCCESS) WriteActionError = Res;
 271     Res = WINTRUST_WriteProviderToReg(GuidString, DiagnosticPolicy, psProvInfo->sTestPolicyProvider);
 272     if (Res != ERROR_SUCCESS) WriteActionError = Res;
 273     Res = WINTRUST_WriteProviderToReg(GuidString, Cleanup         , psProvInfo->sCleanupProvider);
 274     if (Res != ERROR_SUCCESS) WriteActionError = Res;
 275
 276     /* Testing (by restricting access to the registry for some keys) shows that the last failing function
 277      * will be used for last error.
 278      * If the flag WT_ADD_ACTION_ID_RET_RESULT_FLAG is set and there are errors when adding the action
 279      * we have to return FALSE. Errors includes both invalid entries as well as registry errors.
 280      * Testing also showed that one error doesn't stop the registry writes. Every action will be dealt with.
 281      */
 282
 283     if (WriteActionError != ERROR_SUCCESS)
 284     {
 285         SetLastError(WriteActionError);
 286
 287         if (fdwFlags == WT_ADD_ACTION_ID_RET_RESULT_FLAG)
 288             return FALSE;
 289     }
 290
 291     return TRUE;
 292 }
 293
 294 /***********************************************************************
 295  *              WINTRUST_RemoveProviderFromReg
 296  *
 297  * Helper function for WintrustRemoveActionID
 298  *
 299  */
 300 static void WINTRUST_RemoveProviderFromReg(WCHAR* GuidString,
 301                                            const WCHAR* FunctionType)
 302 {
 303     WCHAR ProvKey[MAX_PATH];
 304
 305     /* Create the needed key string */
 306     ProvKey[0]='\0';
 307     lstrcatW(ProvKey, Trust);
 308     lstrcatW(ProvKey, FunctionType);
 309     lstrcatW(ProvKey, GuidString);
 310
 311     /* We don't care about success or failure */
 312     RegDeleteKeyW(HKEY_LOCAL_MACHINE, ProvKey);
 313 }
 314
 315 /***********************************************************************
 316  *              WintrustRemoveActionID (WINTRUST.@)
 317  *
 318  * Remove the definitions of the actions a Trust provider can perform
 319  * from the registry.
 320  *
 321  * PARAMS
 322  *   pgActionID [I] Pointer to a GUID for the Trust provider.
 323  *
 324  * RETURNS
 325  *   Success: TRUE. (Use GetLastError() for more information)
 326  *   Failure: FALSE. (Use GetLastError() for more information)
 327  *
 328  * NOTES
 329  *   Testing shows that WintrustRemoveActionID always returns TRUE and
 330  *   that a possible error should be retrieved via GetLastError().
 331  *   There are no checks if the definitions are in the registry.
 332  */
 333 BOOL WINAPI WintrustRemoveActionID( GUID* pgActionID )
 334 {
 335     WCHAR GuidString[39];
 336
 337     TRACE("(%s)\n", debugstr_guid(pgActionID));
 338
 339     if (!pgActionID)
 340     {
 341         SetLastError(ERROR_INVALID_PARAMETER);
 342         return TRUE;
 343     }
 344
 345     /* Create this string only once, instead of in the helper function */
 346     WINTRUST_Guid2Wstr( pgActionID, GuidString);
 347
 348     /* We don't care about success or failure */
 349     WINTRUST_RemoveProviderFromReg(GuidString, Initialization);
 350     WINTRUST_RemoveProviderFromReg(GuidString, Message);
 351     WINTRUST_RemoveProviderFromReg(GuidString, Signature);
 352     WINTRUST_RemoveProviderFromReg(GuidString, Certificate);
 353     WINTRUST_RemoveProviderFromReg(GuidString, CertCheck);
 354     WINTRUST_RemoveProviderFromReg(GuidString, FinalPolicy);
 355     WINTRUST_RemoveProviderFromReg(GuidString, DiagnosticPolicy);
 356     WINTRUST_RemoveProviderFromReg(GuidString, Cleanup);
 357
 358     return TRUE;
 359 }
 360
 361 /***********************************************************************
 362  *              WINTRUST_WriteSingleUsageEntry
 363  *
 364  * Write a single value and its data to:
 365  *
 366  * HKLM\Software\Microsoft\Cryptography\Trust\Usages\<OID>
 367  */
 368 static LONG WINTRUST_WriteSingleUsageEntry(LPCSTR OID,
 369                                            const WCHAR* Value,
 370                                            WCHAR* Data)
 371 {
 372     static const WCHAR Usages[] = {'U','s','a','g','e','s','\\', 0};
 373     WCHAR* UsageKey;
 374     HKEY Key;
 375     LONG Res = ERROR_SUCCESS;
 376     WCHAR* OIDW;
 377     DWORD Len;
 378
 379     /* Turn OID into a wide-character string */
 380     Len = MultiByteToWideChar( CP_ACP, 0, OID, -1, NULL, 0 );
 381     OIDW = HeapAlloc( GetProcessHeap(), 0, Len * sizeof(WCHAR) );
 382     MultiByteToWideChar( CP_ACP, 0, OID, -1, OIDW, Len );
 383
 384     /* Allocate the needed space for UsageKey */
 385     UsageKey = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(Trust) + lstrlenW(Usages) + Len) * sizeof(WCHAR));
 386     /* Create the key string */
 387     lstrcpyW(UsageKey, Trust);
 388     lstrcatW(UsageKey, Usages);
 389     lstrcatW(UsageKey, OIDW);
 390
 391     Res = RegCreateKeyExW(HKEY_LOCAL_MACHINE, UsageKey, 0, NULL, 0, KEY_WRITE, NULL, &Key, NULL);
 392     if (Res == ERROR_SUCCESS)
 393     {
 394         /* Create the Value entry */
 395         Res = RegSetValueExW(Key, Value, 0, REG_SZ, (BYTE*)Data,
 396                              (lstrlenW(Data) + 1)*sizeof(WCHAR));
 397     }
 398     RegCloseKey(Key);
 399
 400     HeapFree(GetProcessHeap(), 0, OIDW);
 401     HeapFree(GetProcessHeap(), 0, UsageKey);
 402
 403     return Res;
 404 }
 405
 406 /***************************************************************************
 407  *              WINTRUST_RegisterGenVerifyV2
 408  *
 409  * Register WINTRUST_ACTION_GENERIC_VERIFY_V2 actions and usages.
 410  *
 411  * NOTES
 412  *   WINTRUST_ACTION_GENERIC_VERIFY_V2 ({00AAC56B-CD44-11D0-8CC2-00C04FC295EE}
 413  *   is defined in softpub.h
 414  *   We don't care about failures (see comments in DllRegisterServer)
 415  */
 416 static void WINTRUST_RegisterGenVerifyV2(void)
 417 {
 418     static GUID ProvGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
 419     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 420                                          SoftpubInitialization,
 421                                          SoftpubMessage,
 422                                          SoftpubSignature,
 423                                          SoftpubCertficate,
 424                                          SoftpubCertCheck,
 425                                          SoftpubFinalPolicy,
 426                                          { 0, NULL, NULL }, /* No diagnostic policy */
 427                                          SoftpubCleanup };
 428     WCHAR GuidString[39];
 429
 430     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 431
 432     TRACE("Going to register WINTRUST_ACTION_GENERIC_VERIFY_V2 : %s\n", wine_dbgstr_w(GuidString));
 433
 434     /* HKLM\Software\Microsoft\Cryptography\Trust\Usages\1.3.6.1.5.5.7.3.3 */
 435     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_CODE_SIGNING, DefaultId, GuidString);
 436
 437     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 438 }
 439
 440 /***************************************************************************
 441  *              WINTRUST_RegisterPublishedSoftware
 442  *
 443  * Register WIN_SPUB_ACTION_PUBLISHED_SOFTWARE actions and usages.
 444  *
 445  * NOTES
 446  *   WIN_SPUB_ACTION_PUBLISHED_SOFTWARE ({64B9D180-8DA2-11CF-8736-00AA00A485EB})
 447  *   is defined in wintrust.h
 448  *   We don't care about failures (see comments in DllRegisterServer)
 449  */
 450 static void WINTRUST_RegisterPublishedSoftware(void)
 451 {
 452     static GUID ProvGUID = WIN_SPUB_ACTION_PUBLISHED_SOFTWARE;
 453     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 454                                          SoftpubInitialization,
 455                                          SoftpubMessage,
 456                                          SoftpubSignature,
 457                                          SoftpubCertficate,
 458                                          SoftpubCertCheck,
 459                                          SoftpubFinalPolicy,
 460                                          { 0, NULL, NULL }, /* No diagnostic policy */
 461                                          SoftpubCleanup };
 462     WCHAR GuidString[39];
 463
 464     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 465
 466     TRACE("Going to register WIN_SPUB_ACTION_PUBLISHED_SOFTWARE : %s\n", wine_dbgstr_w(GuidString));
 467
 468     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 469 }
 470
 471 #define WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI { 0xc6b2e8d0, 0xe005, 0x11cf, { 0xa1,0x34,0x00,0xc0,0x4f,0xd7,0xbf,0x43 }}
 472
 473 /***************************************************************************
 474  *              WINTRUST_RegisterPublishedSoftwareNoBadUi
 475  *
 476  * Register WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI actions and usages.
 477  *
 478  * NOTES
 479  *   WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI ({C6B2E8D0-E005-11CF-A134-00C04FD7BF43})
 480  *   is not defined in any include file. (FIXME: Find out if the name is correct).
 481  *   We don't care about failures (see comments in DllRegisterServer)
 482  */
 483 static void WINTRUST_RegisterPublishedSoftwareNoBadUi(void)
 484 {
 485     static GUID ProvGUID = WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI;
 486     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 487                                          SoftpubInitialization,
 488                                          SoftpubMessage,
 489                                          SoftpubSignature,
 490                                          SoftpubCertficate,
 491                                          SoftpubCertCheck,
 492                                          SoftpubFinalPolicy,
 493                                          { 0, NULL, NULL }, /* No diagnostic policy */
 494                                          SoftpubCleanup };
 495     WCHAR GuidString[39];
 496
 497     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 498
 499     TRACE("Going to register WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI : %s\n", wine_dbgstr_w(GuidString));
 500
 501     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 502 }
 503
 504 /***************************************************************************
 505  *              WINTRUST_RegisterGenCertVerify
 506  *
 507  * Register WINTRUST_ACTION_GENERIC_CERT_VERIFY actions and usages.
 508  *
 509  * NOTES
 510  *   WINTRUST_ACTION_GENERIC_CERT_VERIFY ({189A3842-3041-11D1-85E1-00C04FC295EE})
 511  *   is defined in softpub.h
 512  *   We don't care about failures (see comments in DllRegisterServer)
 513  */
 514 static void WINTRUST_RegisterGenCertVerify(void)
 515 {
 516     static GUID ProvGUID = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
 517     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 518                                          SoftpubDefCertInit,
 519                                          SoftpubMessage,
 520                                          SoftpubSignature,
 521                                          SoftpubCertficate,
 522                                          SoftpubCertCheck,
 523                                          SoftpubFinalPolicy,
 524                                          { 0, NULL, NULL }, /* No diagnostic policy */
 525                                          SoftpubCleanup };
 526     WCHAR GuidString[39];
 527
 528     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 529
 530     TRACE("Going to register WINTRUST_ACTION_GENERIC_CERT_VERIFY : %s\n", wine_dbgstr_w(GuidString));
 531
 532     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 533 }
 534
 535 /***************************************************************************
 536  *              WINTRUST_RegisterTrustProviderTest
 537  *
 538  * Register WINTRUST_ACTION_TRUSTPROVIDER_TEST actions and usages.
 539  *
 540  * NOTES
 541  *   WINTRUST_ACTION_TRUSTPROVIDER_TEST ({573E31F8-DDBA-11D0-8CCB-00C04FC295EE})
 542  *   is defined in softpub.h
 543  *   We don't care about failures (see comments in DllRegisterServer)
 544  */
 545 static void WINTRUST_RegisterTrustProviderTest(void)
 546 {
 547     static GUID ProvGUID = WINTRUST_ACTION_TRUSTPROVIDER_TEST;
 548     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 549                                          SoftpubInitialization,
 550                                          SoftpubMessage,
 551                                          SoftpubSignature,
 552                                          SoftpubCertficate,
 553                                          SoftpubCertCheck,
 554                                          SoftpubFinalPolicy,
 555                                          SoftpubDumpStructure,
 556                                          SoftpubCleanup };
 557     WCHAR GuidString[39];
 558
 559     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 560
 561     TRACE("Going to register WINTRUST_ACTION_TRUSTPROVIDER_TEST : %s\n", wine_dbgstr_w(GuidString));
 562
 563     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 564 }
 565
 566 /***************************************************************************
 567  *              WINTRUST_RegisterHttpsProv
 568  *
 569  * Register HTTPSPROV_ACTION actions and usages.
 570  *
 571  * NOTES
 572  *   HTTPSPROV_ACTION ({573E31F8-AABA-11D0-8CCB-00C04FC295EE})
 573  *   is defined in softpub.h
 574  *   We don't care about failures (see comments in DllRegisterServer)
 575  */
 576 static void WINTRUST_RegisterHttpsProv(void)
 577 {
 578     static WCHAR SoftpubLoadUsage[] = {'S','o','f','t','p','u','b','L','o','a','d','D','e','f','U','s','a','g','e','C','a','l','l','D','a','t','a', 0};
 579     static WCHAR SoftpubFreeUsage[] = {'S','o','f','t','p','u','b','F','r','e','e','D','e','f','U','s','a','g','e','C','a','l','l','D','a','t','a', 0};
 580     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};
 581     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};
 582     static GUID ProvGUID = HTTPSPROV_ACTION;
 583     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 584                                          SoftpubInitialization,
 585                                          SoftpubMessage,
 586                                          SoftpubSignature,
 587                                          HTTPSCertificateTrust,
 588                                          SoftpubCertCheck,
 589                                          HTTPSFinalProv,
 590                                          { 0, NULL, NULL }, /* No diagnostic policy */
 591                                          SoftpubCleanup };
 592     WCHAR GuidString[39];
 593     WCHAR ProvDllName[sizeof(SP_POLICY_PROVIDER_DLL_NAME)];
 594
 595     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 596
 597     TRACE("Going to register HTTPSPROV_ACTION : %s\n", wine_dbgstr_w(GuidString));
 598
 599     lstrcpyW(ProvDllName, SP_POLICY_PROVIDER_DLL_NAME); \
 600
 601     /* HKLM\Software\Microsoft\Cryptography\Trust\Usages\1.3.6.1.5.5.7.3.1 */
 602     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_SERVER_AUTH, Dll, ProvDllName);
 603     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_SERVER_AUTH, CBAlloc, SoftpubLoadUsage );
 604     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_SERVER_AUTH, CBFree, SoftpubFreeUsage );
 605     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_SERVER_AUTH, DefaultId, GuidString );
 606     /* HKLM\Software\Microsoft\Cryptography\Trust\Usages\1.3.6.1.5.5.7.3.2 */
 607     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_CLIENT_AUTH, Dll, ProvDllName);
 608     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_CLIENT_AUTH, CBAlloc, SoftpubLoadUsage );
 609     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_CLIENT_AUTH, CBFree, SoftpubFreeUsage );
 610     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_CLIENT_AUTH, DefaultId, GuidString );
 611     /* HKLM\Software\Microsoft\Cryptography\Trust\Usages\1.3.6.1.4.1.311.10.3.3 */
 612     WINTRUST_WriteSingleUsageEntry(szOID_SERVER_GATED_CRYPTO, Dll, ProvDllName);
 613     WINTRUST_WriteSingleUsageEntry(szOID_SERVER_GATED_CRYPTO, CBAlloc, SoftpubLoadUsage );
 614     WINTRUST_WriteSingleUsageEntry(szOID_SERVER_GATED_CRYPTO, CBFree, SoftpubFreeUsage );
 615     WINTRUST_WriteSingleUsageEntry(szOID_SERVER_GATED_CRYPTO, DefaultId, GuidString );
 616     /* HKLM\Software\Microsoft\Cryptography\Trust\Usages\2.16.840.1.113730.4.1 */
 617     WINTRUST_WriteSingleUsageEntry(szOID_SGC_NETSCAPE, Dll, ProvDllName);
 618     WINTRUST_WriteSingleUsageEntry(szOID_SGC_NETSCAPE, CBAlloc, SoftpubLoadUsage );
 619     WINTRUST_WriteSingleUsageEntry(szOID_SGC_NETSCAPE, CBFree, SoftpubFreeUsage );
 620     WINTRUST_WriteSingleUsageEntry(szOID_SGC_NETSCAPE, DefaultId, GuidString );
 621
 622     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 623 }
 624
 625 /***************************************************************************
 626  *              WINTRUST_RegisterOfficeSignVerify
 627  *
 628  * Register OFFICESIGN_ACTION_VERIFY actions and usages.
 629  *
 630  * NOTES
 631  *   OFFICESIGN_ACTION_VERIFY ({5555C2CD-17FB-11D1-85C4-00C04FC295EE})
 632  *   is defined in softpub.h
 633  *   We don't care about failures (see comments in DllRegisterServer)
 634  */
 635 static void WINTRUST_RegisterOfficeSignVerify(void)
 636 {
 637     static GUID ProvGUID = OFFICESIGN_ACTION_VERIFY;
 638     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 639                                          OfficeInitializePolicy,
 640                                          SoftpubMessage,
 641                                          SoftpubSignature,
 642                                          SoftpubCertficate,
 643                                          SoftpubCertCheck,
 644                                          SoftpubFinalPolicy,
 645                                          { 0, NULL, NULL }, /* No diagnostic policy */
 646                                          OfficeCleanupPolicy };
 647     WCHAR GuidString[39];
 648
 649     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 650
 651     TRACE("Going to register OFFICESIGN_ACTION_VERIFY : %s\n", wine_dbgstr_w(GuidString));
 652
 653     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 654 }
 655
 656 /***************************************************************************
 657  *              WINTRUST_RegisterDriverVerify
 658  *
 659  * Register DRIVER_ACTION_VERIFY actions and usages.
 660  *
 661  * NOTES
 662  *   DRIVER_ACTION_VERIFY ({F750E6C3-38EE-11D1-85E5-00C04FC295EE})
 663  *   is defined in softpub.h
 664  *   We don't care about failures (see comments in DllRegisterServer)
 665  */
 666 static void WINTRUST_RegisterDriverVerify(void)
 667 {
 668     static GUID ProvGUID = DRIVER_ACTION_VERIFY;
 669     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 670                                          DriverInitializePolicy,
 671                                          SoftpubMessage,
 672                                          SoftpubSignature,
 673                                          SoftpubCertficate,
 674                                          SoftpubCertCheck,
 675                                          DriverFinalPolicy,
 676                                          { 0, NULL, NULL }, /* No diagnostic policy */
 677                                          DriverCleanupPolicy };
 678     WCHAR GuidString[39];
 679
 680     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 681
 682     TRACE("Going to register DRIVER_ACTION_VERIFY : %s\n", wine_dbgstr_w(GuidString));
 683
 684     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 685 }
 686
 687 /***************************************************************************
 688  *              WINTRUST_RegisterGenChainVerify
 689  *
 690  * Register WINTRUST_ACTION_GENERIC_CHAIN_VERIFY actions and usages.
 691  *
 692  * NOTES
 693  *   WINTRUST_ACTION_GENERIC_CHAIN_VERIFY ({FC451C16-AC75-11D1-B4B8-00C04FB66EA0})
 694  *   is defined in softpub.h
 695  *   We don't care about failures (see comments in DllRegisterServer)
 696  */
 697 static void WINTRUST_RegisterGenChainVerify(void)
 698 {
 699     static GUID ProvGUID = WINTRUST_ACTION_GENERIC_CHAIN_VERIFY;
 700     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 701                                          SoftpubInitialization,
 702                                          SoftpubMessage,
 703                                          SoftpubSignature,
 704                                          GenericChainCertificateTrust,
 705                                          SoftpubCertCheck,
 706                                          GenericChainFinalProv,
 707                                          { 0, NULL, NULL }, /* No diagnostic policy */
 708                                          SoftpubCleanup };
 709     WCHAR GuidString[39];
 710
 711     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 712
 713     TRACE("Going to register WINTRUST_ACTION_GENERIC_CHAIN_VERIFY : %s\n", wine_dbgstr_w(GuidString));
 714
 715     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 716 }
 717
 718 /***********************************************************************
 719  *              DllRegisterServer (WINTRUST.@)
 720  */
 721 HRESULT WINAPI DllRegisterServer(void)
 722 {
 723     static const CHAR SpcPeImageDataEncode[]           = "WVTAsn1SpcPeImageDataEncode";
 724     static const CHAR SpcPeImageDataDecode[]           = "WVTAsn1SpcPeImageDataDecode";
 725     static const CHAR SpcLinkEncode[]                  = "WVTAsn1SpcLinkEncode";
 726     static const CHAR SpcLinkDecode[]                  = "WVTAsn1SpcLinkDecode";
 727     static const CHAR SpcSigInfoEncode[]               = "WVTAsn1SpcSigInfoEncode";
 728     static const CHAR SpcSigInfoDecode[]               = "WVTAsn1SpcSigInfoDecode";
 729     static const CHAR SpcIndirectDataContentEncode[]   = "WVTAsn1SpcIndirectDataContentEncode";
 730     static const CHAR SpcIndirectDataContentDecode[]   = "WVTAsn1SpcIndirectDataContentDecode";
 731     static const CHAR SpcSpAgencyInfoEncode[]          = "WVTAsn1SpcSpAgencyInfoEncode";
 732     static const CHAR SpcSpAgencyInfoDecode[]          = "WVTAsn1SpcSpAgencyInfoDecode";
 733     static const CHAR SpcMinimalCriteriaInfoEncode[]   = "WVTAsn1SpcMinimalCriteriaInfoEncode";
 734     static const CHAR SpcMinimalCriteriaInfoDecode[]   = "WVTAsn1SpcMinimalCriteriaInfoDecode";
 735     static const CHAR SpcFinancialCriteriaInfoEncode[] = "WVTAsn1SpcFinancialCriteriaInfoEncode";
 736     static const CHAR SpcFinancialCriteriaInfoDecode[] = "WVTAsn1SpcFinancialCriteriaInfoDecode";
 737     static const CHAR SpcStatementTypeEncode[]         = "WVTAsn1SpcStatementTypeEncode";
 738     static const CHAR SpcStatementTypeDecode[]         = "WVTAsn1SpcStatementTypeDecode";
 739     static const CHAR CatNameValueEncode[]             = "WVTAsn1CatNameValueEncode";
 740     static const CHAR CatNameValueDecode[]             = "WVTAsn1CatNameValueDecode";
 741     static const CHAR CatMemberInfoEncode[]            = "WVTAsn1CatMemberInfoEncode";
 742     static const CHAR CatMemberInfoDecode[]            = "WVTAsn1CatMemberInfoDecode";
 743     static const CHAR SpcSpOpusInfoEncode[]            = "WVTAsn1SpcSpOpusInfoEncode";
 744     static const CHAR SpcSpOpusInfoDecode[]            = "WVTAsn1SpcSpOpusInfoDecode";
 745     HRESULT Res = S_OK;
 746     HKEY Key;
 747
 748     TRACE("\n");
 749
 750     /* FIXME:
 751      *
 752      * A short list of stuff that should be done here:
 753      *
 754      * - Several calls to CryptRegisterOIDFunction
 755      * - Several action registrations (NOT through WintrustAddActionID)
 756      * - Several calls to CryptSIPAddProvider
 757      * - One call to CryptSIPRemoveProvider (do we need that?)
 758      */
 759
 760     /* Testing on native shows that when an error is encountered in one of the CryptRegisterOIDFunction calls
 761      * the rest of these calls is skipped. Registering is however continued for the trust providers.
 762      *
 763      * We are not totally in line with native as there all decoding functions are registered after all encoding
 764      * functions.
 765      */
 766 #define WINTRUST_REGISTEROID( oid, encode_funcname, decode_funcname ) \
 767     do { \
 768         if (!CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_ENCODE_OBJECT_FUNC, oid, SP_POLICY_PROVIDER_DLL_NAME, encode_funcname)) \
 769         {                                                               \
 770             Res = HRESULT_FROM_WIN32(GetLastError());                   \
 771             goto add_trust_providers;                                   \
 772         }                                                               \
 773         if (!CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_DECODE_OBJECT_FUNC, oid, SP_POLICY_PROVIDER_DLL_NAME, decode_funcname)) \
 774         {                                                               \
 775             Res = HRESULT_FROM_WIN32(GetLastError());                   \
 776             goto add_trust_providers;                                   \
 777         }                                                               \
 778     } while (0)
 779
 780     WINTRUST_REGISTEROID(SPC_PE_IMAGE_DATA_OBJID, SpcPeImageDataEncode, SpcPeImageDataDecode);
 781     WINTRUST_REGISTEROID(SPC_PE_IMAGE_DATA_STRUCT, SpcPeImageDataEncode, SpcPeImageDataDecode);
 782     WINTRUST_REGISTEROID(SPC_CAB_DATA_OBJID, SpcLinkEncode, SpcLinkDecode);
 783     WINTRUST_REGISTEROID(SPC_CAB_DATA_STRUCT, SpcLinkEncode, SpcLinkDecode);
 784     WINTRUST_REGISTEROID(SPC_JAVA_CLASS_DATA_OBJID, SpcLinkEncode, SpcLinkDecode);
 785     WINTRUST_REGISTEROID(SPC_JAVA_CLASS_DATA_STRUCT, SpcLinkEncode, SpcLinkDecode);
 786     WINTRUST_REGISTEROID(SPC_LINK_OBJID, SpcLinkEncode, SpcLinkDecode);
 787     WINTRUST_REGISTEROID(SPC_LINK_STRUCT, SpcLinkEncode, SpcLinkDecode);
 788     WINTRUST_REGISTEROID(SPC_SIGINFO_OBJID, SpcSigInfoEncode, SpcSigInfoDecode);
 789     WINTRUST_REGISTEROID(SPC_SIGINFO_STRUCT, SpcSigInfoEncode, SpcSigInfoDecode);
 790     WINTRUST_REGISTEROID(SPC_INDIRECT_DATA_OBJID, SpcIndirectDataContentEncode, SpcIndirectDataContentDecode);
 791     WINTRUST_REGISTEROID(SPC_INDIRECT_DATA_CONTENT_STRUCT, SpcIndirectDataContentEncode, SpcIndirectDataContentDecode);
 792     WINTRUST_REGISTEROID(SPC_SP_AGENCY_INFO_OBJID, SpcSpAgencyInfoEncode, SpcSpAgencyInfoDecode);
 793     WINTRUST_REGISTEROID(SPC_SP_AGENCY_INFO_STRUCT, SpcSpAgencyInfoEncode, SpcSpAgencyInfoDecode);
 794     WINTRUST_REGISTEROID(SPC_MINIMAL_CRITERIA_OBJID, SpcMinimalCriteriaInfoEncode, SpcMinimalCriteriaInfoDecode);
 795     WINTRUST_REGISTEROID(SPC_MINIMAL_CRITERIA_STRUCT, SpcMinimalCriteriaInfoEncode, SpcMinimalCriteriaInfoDecode);
 796     WINTRUST_REGISTEROID(SPC_FINANCIAL_CRITERIA_OBJID, SpcFinancialCriteriaInfoEncode, SpcFinancialCriteriaInfoDecode);
 797     WINTRUST_REGISTEROID(SPC_FINANCIAL_CRITERIA_STRUCT, SpcFinancialCriteriaInfoEncode, SpcFinancialCriteriaInfoDecode);
 798     WINTRUST_REGISTEROID(SPC_STATEMENT_TYPE_OBJID, SpcStatementTypeEncode, SpcStatementTypeDecode);
 799     WINTRUST_REGISTEROID(SPC_STATEMENT_TYPE_STRUCT, SpcStatementTypeEncode, SpcStatementTypeDecode);
 800     WINTRUST_REGISTEROID(CAT_NAMEVALUE_OBJID, CatNameValueEncode, CatNameValueDecode);
 801     WINTRUST_REGISTEROID(CAT_NAMEVALUE_STRUCT, CatNameValueEncode, CatNameValueDecode);
 802     WINTRUST_REGISTEROID(CAT_MEMBERINFO_OBJID, CatMemberInfoEncode, CatMemberInfoDecode);
 803     WINTRUST_REGISTEROID(CAT_MEMBERINFO_STRUCT, CatMemberInfoEncode, CatMemberInfoDecode);
 804     WINTRUST_REGISTEROID(SPC_SP_OPUS_INFO_OBJID, SpcSpOpusInfoEncode, SpcSpOpusInfoDecode);
 805     WINTRUST_REGISTEROID(SPC_SP_OPUS_INFO_STRUCT, SpcSpOpusInfoEncode,  SpcSpOpusInfoDecode);
 806
 807 #undef WINTRUST_REGISTEROID
 808
 809 add_trust_providers:
 810
 811     /* Testing on W2K3 shows:
 812      * If we cannot open HKLM\Software\Microsoft\Cryptography\Providers\Trust
 813      * for writing, DllRegisterServer returns S_FALSE. If the key can be opened
 814      * there is no check whether the actions can be written in the registry.
 815      * As the previous list shows, there are several calls after these registrations.
 816      * If they fail they will overwrite the returnvalue of DllRegisterServer.
 817      */
 818
 819     /* Check if we can open/create HKLM\Software\Microsoft\Cryptography\Providers\Trust */
 820     if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, Trust, 0, NULL, 0, KEY_WRITE, NULL, &Key, NULL) != ERROR_SUCCESS)
 821     {
 822         /* If the opening/creation of the key fails, there is no need to do the action registrations as they
 823          * will fail as well.
 824          */
 825         Res = S_FALSE;
 826     }
 827     else
 828     {
 829         RegCloseKey(Key);
 830
 831         /* Create the necessary action registry structures */
 832         WINTRUST_InitRegStructs();
 833
 834         /* Register several Trust Provider actions */
 835         WINTRUST_RegisterGenVerifyV2();
 836         WINTRUST_RegisterPublishedSoftware();
 837         WINTRUST_RegisterPublishedSoftwareNoBadUi();
 838         WINTRUST_RegisterGenCertVerify();
 839         WINTRUST_RegisterTrustProviderTest();
 840         WINTRUST_RegisterHttpsProv();
 841         WINTRUST_RegisterOfficeSignVerify();
 842         WINTRUST_RegisterDriverVerify();
 843         WINTRUST_RegisterGenChainVerify();
 844
 845         /* Free the registry structures */
 846         WINTRUST_FreeRegStructs();
 847     }
 848
 849     return Res;
 850 }
 851
 852 /***********************************************************************
 853  *              DllUnregisterServer (WINTRUST.@)
 854  */
 855 HRESULT WINAPI DllUnregisterServer(void)
 856 {
 857      FIXME("stub\n");
 858      return S_OK;
 859 }
 860
 861 /***********************************************************************
 862  *              SoftpubDllRegisterServer (WINTRUST.@)
 863  */
 864 HRESULT WINAPI SoftpubDllRegisterServer(void)
 865 {
 866      FIXME("stub\n");
 867      return S_OK;
 868 }
 869
 870 /***********************************************************************
 871  *              SoftpubDllUnregisterServer (WINTRUST.@)
 872  */
 873 HRESULT WINAPI SoftpubDllUnregisterServer(void)
 874 {
 875      FIXME("stub\n");
 876      return S_OK;
 877 }
 878
 879 /***********************************************************************
 880  *              mscat32DllRegisterServer (WINTRUST.@)
 881  */
 882 HRESULT WINAPI mscat32DllRegisterServer(void)
 883 {
 884      FIXME("stub\n");
 885      return S_OK;
 886 }
 887
 888 /***********************************************************************
 889  *              mscat32DllUnregisterServer (WINTRUST.@)
 890  */
 891 HRESULT WINAPI mscat32DllUnregisterServer(void)
 892 {
 893      FIXME("stub\n");
 894      return S_OK;
 895 }
 896
 897 /***********************************************************************
 898  *              mssip32DllRegisterServer (WINTRUST.@)
 899  */
 900 HRESULT WINAPI mssip32DllRegisterServer(void)
 901 {
 902      FIXME("stub\n");
 903      return S_OK;
 904 }
 905
 906 /***********************************************************************
 907  *              mssip32DllUnregisterServer (WINTRUST.@)
 908  */
 909 HRESULT WINAPI mssip32DllUnregisterServer(void)
 910 {
 911      FIXME("stub\n");
 912      return S_OK;
 913 }