git.oblomov.eu Git - wine/blob - 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("%s %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
 463     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 464 }
 465
 466 #define WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI { 0xc6b2e8d0, 0xe005, 0x11cf, { 0xa1,0x34,0x00,0xc0,0x4f,0xd7,0xbf,0x43 }}
 467
 468 /***************************************************************************
 469  *              WINTRUST_RegisterPublishedSoftwareNoBadUi
 470  *
 471  * Register WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI actions and usages.
 472  *
 473  * NOTES
 474  *   WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI ({C6B2E8D0-E005-11CF-A134-00C04FD7BF43})
 475  *   is not defined in any include file. (FIXME: Find out if the name is correct).
 476  *   We don't care about failures (see comments in DllRegisterServer)
 477  */
 478 static void WINTRUST_RegisterPublishedSoftwareNoBadUi(void)
 479 {
 480     static GUID ProvGUID = WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI;
 481     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 482                                          SoftpubInitialization,
 483                                          SoftpubMessage,
 484                                          SoftpubSignature,
 485                                          SoftpubCertficate,
 486                                          SoftpubCertCheck,
 487                                          SoftpubFinalPolicy,
 488                                          { 0, NULL, NULL }, /* No diagnostic policy */
 489                                          SoftpubCleanup };
 490     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 491 }
 492
 493 /***************************************************************************
 494  *              WINTRUST_RegisterGenCertVerify
 495  *
 496  * Register WINTRUST_ACTION_GENERIC_CERT_VERIFY actions and usages.
 497  *
 498  * NOTES
 499  *   WINTRUST_ACTION_GENERIC_CERT_VERIFY ({189A3842-3041-11D1-85E1-00C04FC295EE})
 500  *   is defined in softpub.h
 501  *   We don't care about failures (see comments in DllRegisterServer)
 502  */
 503 static void WINTRUST_RegisterGenCertVerify(void)
 504 {
 505     static GUID ProvGUID = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
 506     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 507                                          SoftpubDefCertInit,
 508                                          SoftpubMessage,
 509                                          SoftpubSignature,
 510                                          SoftpubCertficate,
 511                                          SoftpubCertCheck,
 512                                          SoftpubFinalPolicy,
 513                                          { 0, NULL, NULL }, /* No diagnostic policy */
 514                                          SoftpubCleanup };
 515
 516     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 517 }
 518
 519 /***************************************************************************
 520  *              WINTRUST_RegisterTrustProviderTest
 521  *
 522  * Register WINTRUST_ACTION_TRUSTPROVIDER_TEST actions and usages.
 523  *
 524  * NOTES
 525  *   WINTRUST_ACTION_TRUSTPROVIDER_TEST ({573E31F8-DDBA-11D0-8CCB-00C04FC295EE})
 526  *   is defined in softpub.h
 527  *   We don't care about failures (see comments in DllRegisterServer)
 528  */
 529 static void WINTRUST_RegisterTrustProviderTest(void)
 530 {
 531     static GUID ProvGUID = WINTRUST_ACTION_TRUSTPROVIDER_TEST;
 532     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 533                                          SoftpubInitialization,
 534                                          SoftpubMessage,
 535                                          SoftpubSignature,
 536                                          SoftpubCertficate,
 537                                          SoftpubCertCheck,
 538                                          SoftpubFinalPolicy,
 539                                          SoftpubDumpStructure,
 540                                          SoftpubCleanup };
 541
 542     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 543 }
 544
 545 /***************************************************************************
 546  *              WINTRUST_RegisterHttpsProv
 547  *
 548  * Register HTTPSPROV_ACTION actions and usages.
 549  *
 550  * NOTES
 551  *   HTTPSPROV_ACTION ({573E31F8-AABA-11D0-8CCB-00C04FC295EE})
 552  *   is defined in softpub.h
 553  *   We don't care about failures (see comments in DllRegisterServer)
 554  */
 555 static void WINTRUST_RegisterHttpsProv(void)
 556 {
 557     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};
 558     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};
 559     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};
 560     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};
 561     static GUID ProvGUID = HTTPSPROV_ACTION;
 562     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 563                                          SoftpubInitialization,
 564                                          SoftpubMessage,
 565                                          SoftpubSignature,
 566                                          HTTPSCertificateTrust,
 567                                          SoftpubCertCheck,
 568                                          HTTPSFinalProv,
 569                                          { 0, NULL, NULL }, /* No diagnostic policy */
 570                                          SoftpubCleanup };
 571     WCHAR GuidString[39];
 572     WCHAR ProvDllName[sizeof(SP_POLICY_PROVIDER_DLL_NAME)];
 573
 574     WINTRUST_Guid2Wstr(&ProvGUID , GuidString);
 575
 576     TRACE("Going to register HTTPSPROV_ACTION : %s\n", wine_dbgstr_w(GuidString));
 577
 578     lstrcpyW(ProvDllName, SP_POLICY_PROVIDER_DLL_NAME);
 579
 580     /* HKLM\Software\Microsoft\Cryptography\Trust\Usages\1.3.6.1.5.5.7.3.1 */
 581     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_SERVER_AUTH, Dll, ProvDllName);
 582     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_SERVER_AUTH, CBAlloc, SoftpubLoadUsage );
 583     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_SERVER_AUTH, CBFree, SoftpubFreeUsage );
 584     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_SERVER_AUTH, DefaultId, GuidString );
 585     /* HKLM\Software\Microsoft\Cryptography\Trust\Usages\1.3.6.1.5.5.7.3.2 */
 586     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_CLIENT_AUTH, Dll, ProvDllName);
 587     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_CLIENT_AUTH, CBAlloc, SoftpubLoadUsage );
 588     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_CLIENT_AUTH, CBFree, SoftpubFreeUsage );
 589     WINTRUST_WriteSingleUsageEntry(szOID_PKIX_KP_CLIENT_AUTH, DefaultId, GuidString );
 590     /* HKLM\Software\Microsoft\Cryptography\Trust\Usages\1.3.6.1.4.1.311.10.3.3 */
 591     WINTRUST_WriteSingleUsageEntry(szOID_SERVER_GATED_CRYPTO, Dll, ProvDllName);
 592     WINTRUST_WriteSingleUsageEntry(szOID_SERVER_GATED_CRYPTO, CBAlloc, SoftpubLoadUsage );
 593     WINTRUST_WriteSingleUsageEntry(szOID_SERVER_GATED_CRYPTO, CBFree, SoftpubFreeUsage );
 594     WINTRUST_WriteSingleUsageEntry(szOID_SERVER_GATED_CRYPTO, DefaultId, GuidString );
 595     /* HKLM\Software\Microsoft\Cryptography\Trust\Usages\2.16.840.1.113730.4.1 */
 596     WINTRUST_WriteSingleUsageEntry(szOID_SGC_NETSCAPE, Dll, ProvDllName);
 597     WINTRUST_WriteSingleUsageEntry(szOID_SGC_NETSCAPE, CBAlloc, SoftpubLoadUsage );
 598     WINTRUST_WriteSingleUsageEntry(szOID_SGC_NETSCAPE, CBFree, SoftpubFreeUsage );
 599     WINTRUST_WriteSingleUsageEntry(szOID_SGC_NETSCAPE, DefaultId, GuidString );
 600
 601     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 602 }
 603
 604 /***************************************************************************
 605  *              WINTRUST_RegisterOfficeSignVerify
 606  *
 607  * Register OFFICESIGN_ACTION_VERIFY actions and usages.
 608  *
 609  * NOTES
 610  *   OFFICESIGN_ACTION_VERIFY ({5555C2CD-17FB-11D1-85C4-00C04FC295EE})
 611  *   is defined in softpub.h
 612  *   We don't care about failures (see comments in DllRegisterServer)
 613  */
 614 static void WINTRUST_RegisterOfficeSignVerify(void)
 615 {
 616     static GUID ProvGUID = OFFICESIGN_ACTION_VERIFY;
 617     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 618                                          OfficeInitializePolicy,
 619                                          SoftpubMessage,
 620                                          SoftpubSignature,
 621                                          SoftpubCertficate,
 622                                          SoftpubCertCheck,
 623                                          SoftpubFinalPolicy,
 624                                          { 0, NULL, NULL }, /* No diagnostic policy */
 625                                          OfficeCleanupPolicy };
 626
 627     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 628 }
 629
 630 /***************************************************************************
 631  *              WINTRUST_RegisterDriverVerify
 632  *
 633  * Register DRIVER_ACTION_VERIFY actions and usages.
 634  *
 635  * NOTES
 636  *   DRIVER_ACTION_VERIFY ({F750E6C3-38EE-11D1-85E5-00C04FC295EE})
 637  *   is defined in softpub.h
 638  *   We don't care about failures (see comments in DllRegisterServer)
 639  */
 640 static void WINTRUST_RegisterDriverVerify(void)
 641 {
 642     static GUID ProvGUID = DRIVER_ACTION_VERIFY;
 643     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 644                                          DriverInitializePolicy,
 645                                          SoftpubMessage,
 646                                          SoftpubSignature,
 647                                          SoftpubCertficate,
 648                                          SoftpubCertCheck,
 649                                          DriverFinalPolicy,
 650                                          { 0, NULL, NULL }, /* No diagnostic policy */
 651                                          DriverCleanupPolicy };
 652
 653     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 654 }
 655
 656 /***************************************************************************
 657  *              WINTRUST_RegisterGenChainVerify
 658  *
 659  * Register WINTRUST_ACTION_GENERIC_CHAIN_VERIFY actions and usages.
 660  *
 661  * NOTES
 662  *   WINTRUST_ACTION_GENERIC_CHAIN_VERIFY ({FC451C16-AC75-11D1-B4B8-00C04FB66EA0})
 663  *   is defined in softpub.h
 664  *   We don't care about failures (see comments in DllRegisterServer)
 665  */
 666 static void WINTRUST_RegisterGenChainVerify(void)
 667 {
 668     static GUID ProvGUID = WINTRUST_ACTION_GENERIC_CHAIN_VERIFY;
 669     CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
 670                                          SoftpubInitialization,
 671                                          SoftpubMessage,
 672                                          SoftpubSignature,
 673                                          GenericChainCertificateTrust,
 674                                          SoftpubCertCheck,
 675                                          GenericChainFinalProv,
 676                                          { 0, NULL, NULL }, /* No diagnostic policy */
 677                                          SoftpubCleanup };
 678
 679     WintrustAddActionID(&ProvGUID, 0, &ProvInfo);
 680 }
 681
 682 /***********************************************************************
 683  *              WintrustAddDefaultForUsage (WINTRUST.@)
 684  *
 685  * Write OID and callback functions to the registry.
 686  *
 687  * PARAMS
 688  *   pszUsageOID [I] Pointer to a GUID.
 689  *   psDefUsage  [I] Pointer to a structure that specifies the callback functions.
 690  *
 691  * RETURNS
 692  *   Success: TRUE.
 693  *   Failure: FALSE.
 694  *
 695  * NOTES
 696  *   WintrustAddDefaultForUsage will only return TRUE or FALSE, no last
 697  *   error is set, not even when the registry cannot be written to.
 698  */
 699 BOOL WINAPI WintrustAddDefaultForUsage(const CHAR *pszUsageOID,
 700                                        CRYPT_PROVIDER_REGDEFUSAGE *psDefUsage)
 701 {
 702     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};
 703     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};
 704     LONG Res = ERROR_SUCCESS;
 705     LONG WriteUsageError = ERROR_SUCCESS;
 706     DWORD Len;
 707     WCHAR GuidString[39];
 708
 709     TRACE("(%s %p)\n", debugstr_a(pszUsageOID), psDefUsage);
 710
 711     /* Some sanity checks. */
 712     if (!pszUsageOID ||
 713         !psDefUsage ||
 714         !psDefUsage->pgActionID ||
 715         (psDefUsage->cbStruct != sizeof(CRYPT_PROVIDER_REGDEFUSAGE)))
 716     {
 717         SetLastError(ERROR_INVALID_PARAMETER);
 718         return FALSE;
 719     }
 720
 721     if (psDefUsage->pwszDllName)
 722     {
 723         Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, Dll, psDefUsage->pwszDllName);
 724         if (Res != ERROR_SUCCESS) WriteUsageError = Res;
 725     }
 726     if (psDefUsage->pwszLoadCallbackDataFunctionName)
 727     {
 728         WCHAR* CallbackW;
 729
 730         Len = MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszLoadCallbackDataFunctionName, -1, NULL, 0 );
 731         CallbackW = HeapAlloc( GetProcessHeap(), 0, Len * sizeof(WCHAR) );
 732         MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszLoadCallbackDataFunctionName, -1, CallbackW, Len );
 733
 734         Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, CBAlloc, CallbackW);
 735         if (Res != ERROR_SUCCESS) WriteUsageError = Res;
 736
 737         HeapFree(GetProcessHeap(), 0, CallbackW);
 738     }
 739     if (psDefUsage->pwszFreeCallbackDataFunctionName)
 740     {
 741         WCHAR* CallbackW;
 742
 743         Len = MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszFreeCallbackDataFunctionName, -1, NULL, 0 );
 744         CallbackW = HeapAlloc( GetProcessHeap(), 0, Len * sizeof(WCHAR) );
 745         MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszFreeCallbackDataFunctionName, -1, CallbackW, Len );
 746
 747         Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, CBFree, CallbackW);
 748         if (Res != ERROR_SUCCESS) WriteUsageError = Res;
 749
 750         HeapFree(GetProcessHeap(), 0, CallbackW);
 751     }
 752
 753     WINTRUST_Guid2Wstr(psDefUsage->pgActionID, GuidString);
 754     Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, DefaultId, GuidString);
 755     if (Res != ERROR_SUCCESS) WriteUsageError = Res;
 756
 757     if (WriteUsageError != ERROR_SUCCESS)
 758         return FALSE;
 759
 760     return TRUE;
 761 }
 762
 763 /***********************************************************************
 764  *              DllRegisterServer (WINTRUST.@)
 765  */
 766 HRESULT WINAPI DllRegisterServer(void)
 767 {
 768     static const CHAR SpcPeImageDataEncode[]           = "WVTAsn1SpcPeImageDataEncode";
 769     static const CHAR SpcPeImageDataDecode[]           = "WVTAsn1SpcPeImageDataDecode";
 770     static const CHAR SpcLinkEncode[]                  = "WVTAsn1SpcLinkEncode";
 771     static const CHAR SpcLinkDecode[]                  = "WVTAsn1SpcLinkDecode";
 772     static const CHAR SpcSigInfoEncode[]               = "WVTAsn1SpcSigInfoEncode";
 773     static const CHAR SpcSigInfoDecode[]               = "WVTAsn1SpcSigInfoDecode";
 774     static const CHAR SpcIndirectDataContentEncode[]   = "WVTAsn1SpcIndirectDataContentEncode";
 775     static const CHAR SpcIndirectDataContentDecode[]   = "WVTAsn1SpcIndirectDataContentDecode";
 776     static const CHAR SpcSpAgencyInfoEncode[]          = "WVTAsn1SpcSpAgencyInfoEncode";
 777     static const CHAR SpcSpAgencyInfoDecode[]          = "WVTAsn1SpcSpAgencyInfoDecode";
 778     static const CHAR SpcMinimalCriteriaInfoEncode[]   = "WVTAsn1SpcMinimalCriteriaInfoEncode";
 779     static const CHAR SpcMinimalCriteriaInfoDecode[]   = "WVTAsn1SpcMinimalCriteriaInfoDecode";
 780     static const CHAR SpcFinancialCriteriaInfoEncode[] = "WVTAsn1SpcFinancialCriteriaInfoEncode";
 781     static const CHAR SpcFinancialCriteriaInfoDecode[] = "WVTAsn1SpcFinancialCriteriaInfoDecode";
 782     static const CHAR SpcStatementTypeEncode[]         = "WVTAsn1SpcStatementTypeEncode";
 783     static const CHAR SpcStatementTypeDecode[]         = "WVTAsn1SpcStatementTypeDecode";
 784     static const CHAR CatNameValueEncode[]             = "WVTAsn1CatNameValueEncode";
 785     static const CHAR CatNameValueDecode[]             = "WVTAsn1CatNameValueDecode";
 786     static const CHAR CatMemberInfoEncode[]            = "WVTAsn1CatMemberInfoEncode";
 787     static const CHAR CatMemberInfoDecode[]            = "WVTAsn1CatMemberInfoDecode";
 788     static const CHAR SpcSpOpusInfoEncode[]            = "WVTAsn1SpcSpOpusInfoEncode";
 789     static const CHAR SpcSpOpusInfoDecode[]            = "WVTAsn1SpcSpOpusInfoDecode";
 790     HRESULT Res = S_OK;
 791     HKEY Key;
 792
 793     TRACE("\n");
 794
 795     /* FIXME:
 796      *
 797      * A short list of stuff that should be done here:
 798      *
 799      * - Several calls to CryptRegisterOIDFunction
 800      * - Several action registrations (NOT through WintrustAddActionID)
 801      * - Several calls to CryptSIPAddProvider
 802      * - One call to CryptSIPRemoveProvider (do we need that?)
 803      */
 804
 805     /* Testing on native shows that when an error is encountered in one of the CryptRegisterOIDFunction calls
 806      * the rest of these calls is skipped. Registering is however continued for the trust providers.
 807      *
 808      * We are not totally in line with native as there all decoding functions are registered after all encoding
 809      * functions.
 810      */
 811 #define WINTRUST_REGISTEROID( oid, encode_funcname, decode_funcname ) \
 812     do { \
 813         if (!CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_ENCODE_OBJECT_FUNC, oid, SP_POLICY_PROVIDER_DLL_NAME, encode_funcname)) \
 814         {                                                               \
 815             Res = HRESULT_FROM_WIN32(GetLastError());                   \
 816             goto add_trust_providers;                                   \
 817         }                                                               \
 818         if (!CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_DECODE_OBJECT_FUNC, oid, SP_POLICY_PROVIDER_DLL_NAME, decode_funcname)) \
 819         {                                                               \
 820             Res = HRESULT_FROM_WIN32(GetLastError());                   \
 821             goto add_trust_providers;                                   \
 822         }                                                               \
 823     } while (0)
 824
 825     WINTRUST_REGISTEROID(SPC_PE_IMAGE_DATA_OBJID, SpcPeImageDataEncode, SpcPeImageDataDecode);
 826     WINTRUST_REGISTEROID(SPC_PE_IMAGE_DATA_STRUCT, SpcPeImageDataEncode, SpcPeImageDataDecode);
 827     WINTRUST_REGISTEROID(SPC_CAB_DATA_OBJID, SpcLinkEncode, SpcLinkDecode);
 828     WINTRUST_REGISTEROID(SPC_CAB_DATA_STRUCT, SpcLinkEncode, SpcLinkDecode);
 829     WINTRUST_REGISTEROID(SPC_JAVA_CLASS_DATA_OBJID, SpcLinkEncode, SpcLinkDecode);
 830     WINTRUST_REGISTEROID(SPC_JAVA_CLASS_DATA_STRUCT, SpcLinkEncode, SpcLinkDecode);
 831     WINTRUST_REGISTEROID(SPC_LINK_OBJID, SpcLinkEncode, SpcLinkDecode);
 832     WINTRUST_REGISTEROID(SPC_LINK_STRUCT, SpcLinkEncode, SpcLinkDecode);
 833     WINTRUST_REGISTEROID(SPC_SIGINFO_OBJID, SpcSigInfoEncode, SpcSigInfoDecode);
 834     WINTRUST_REGISTEROID(SPC_SIGINFO_STRUCT, SpcSigInfoEncode, SpcSigInfoDecode);
 835     WINTRUST_REGISTEROID(SPC_INDIRECT_DATA_OBJID, SpcIndirectDataContentEncode, SpcIndirectDataContentDecode);
 836     WINTRUST_REGISTEROID(SPC_INDIRECT_DATA_CONTENT_STRUCT, SpcIndirectDataContentEncode, SpcIndirectDataContentDecode);
 837     WINTRUST_REGISTEROID(SPC_SP_AGENCY_INFO_OBJID, SpcSpAgencyInfoEncode, SpcSpAgencyInfoDecode);
 838     WINTRUST_REGISTEROID(SPC_SP_AGENCY_INFO_STRUCT, SpcSpAgencyInfoEncode, SpcSpAgencyInfoDecode);
 839     WINTRUST_REGISTEROID(SPC_MINIMAL_CRITERIA_OBJID, SpcMinimalCriteriaInfoEncode, SpcMinimalCriteriaInfoDecode);
 840     WINTRUST_REGISTEROID(SPC_MINIMAL_CRITERIA_STRUCT, SpcMinimalCriteriaInfoEncode, SpcMinimalCriteriaInfoDecode);
 841     WINTRUST_REGISTEROID(SPC_FINANCIAL_CRITERIA_OBJID, SpcFinancialCriteriaInfoEncode, SpcFinancialCriteriaInfoDecode);
 842     WINTRUST_REGISTEROID(SPC_FINANCIAL_CRITERIA_STRUCT, SpcFinancialCriteriaInfoEncode, SpcFinancialCriteriaInfoDecode);
 843     WINTRUST_REGISTEROID(SPC_STATEMENT_TYPE_OBJID, SpcStatementTypeEncode, SpcStatementTypeDecode);
 844     WINTRUST_REGISTEROID(SPC_STATEMENT_TYPE_STRUCT, SpcStatementTypeEncode, SpcStatementTypeDecode);
 845     WINTRUST_REGISTEROID(CAT_NAMEVALUE_OBJID, CatNameValueEncode, CatNameValueDecode);
 846     WINTRUST_REGISTEROID(CAT_NAMEVALUE_STRUCT, CatNameValueEncode, CatNameValueDecode);
 847     WINTRUST_REGISTEROID(CAT_MEMBERINFO_OBJID, CatMemberInfoEncode, CatMemberInfoDecode);
 848     WINTRUST_REGISTEROID(CAT_MEMBERINFO_STRUCT, CatMemberInfoEncode, CatMemberInfoDecode);
 849     WINTRUST_REGISTEROID(SPC_SP_OPUS_INFO_OBJID, SpcSpOpusInfoEncode, SpcSpOpusInfoDecode);
 850     WINTRUST_REGISTEROID(SPC_SP_OPUS_INFO_STRUCT, SpcSpOpusInfoEncode,  SpcSpOpusInfoDecode);
 851
 852 #undef WINTRUST_REGISTEROID
 853
 854 add_trust_providers:
 855
 856     /* Testing on W2K3 shows:
 857      * If we cannot open HKLM\Software\Microsoft\Cryptography\Providers\Trust
 858      * for writing, DllRegisterServer returns S_FALSE. If the key can be opened
 859      * there is no check whether the actions can be written in the registry.
 860      * As the previous list shows, there are several calls after these registrations.
 861      * If they fail they will overwrite the returnvalue of DllRegisterServer.
 862      */
 863
 864     /* Check if we can open/create HKLM\Software\Microsoft\Cryptography\Providers\Trust */
 865     if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, Trust, 0, NULL, 0, KEY_WRITE, NULL, &Key, NULL) != ERROR_SUCCESS)
 866     {
 867         /* If the opening/creation of the key fails, there is no need to do the action registrations as they
 868          * will fail as well.
 869          */
 870         Res = S_FALSE;
 871     }
 872     else
 873     {
 874         RegCloseKey(Key);
 875
 876         /* Create the necessary action registry structures */
 877         WINTRUST_InitRegStructs();
 878
 879         /* Register several Trust Provider actions */
 880         WINTRUST_RegisterGenVerifyV2();
 881         WINTRUST_RegisterPublishedSoftware();
 882         WINTRUST_RegisterPublishedSoftwareNoBadUi();
 883         WINTRUST_RegisterGenCertVerify();
 884         WINTRUST_RegisterTrustProviderTest();
 885         WINTRUST_RegisterHttpsProv();
 886         WINTRUST_RegisterOfficeSignVerify();
 887         WINTRUST_RegisterDriverVerify();
 888         WINTRUST_RegisterGenChainVerify();
 889
 890         /* Free the registry structures */
 891         WINTRUST_FreeRegStructs();
 892     }
 893
 894     return Res;
 895 }
 896
 897 /***********************************************************************
 898  *              DllUnregisterServer (WINTRUST.@)
 899  */
 900 HRESULT WINAPI DllUnregisterServer(void)
 901 {
 902      FIXME("stub\n");
 903      return S_OK;
 904 }
 905
 906 /***********************************************************************
 907  *              SoftpubDllRegisterServer (WINTRUST.@)
 908  */
 909 HRESULT WINAPI SoftpubDllRegisterServer(void)
 910 {
 911      FIXME("stub\n");
 912      return S_OK;
 913 }
 914
 915 /***********************************************************************
 916  *              SoftpubDllUnregisterServer (WINTRUST.@)
 917  */
 918 HRESULT WINAPI SoftpubDllUnregisterServer(void)
 919 {
 920      FIXME("stub\n");
 921      return S_OK;
 922 }
 923
 924 /***********************************************************************
 925  *              mscat32DllRegisterServer (WINTRUST.@)
 926  */
 927 HRESULT WINAPI mscat32DllRegisterServer(void)
 928 {
 929      FIXME("stub\n");
 930      return S_OK;
 931 }
 932
 933 /***********************************************************************
 934  *              mscat32DllUnregisterServer (WINTRUST.@)
 935  */
 936 HRESULT WINAPI mscat32DllUnregisterServer(void)
 937 {
 938      FIXME("stub\n");
 939      return S_OK;
 940 }
 941
 942 /***********************************************************************
 943  *              mssip32DllRegisterServer (WINTRUST.@)
 944  */
 945 HRESULT WINAPI mssip32DllRegisterServer(void)
 946 {
 947      FIXME("stub\n");
 948      return S_OK;
 949 }
 950
 951 /***********************************************************************
 952  *              mssip32DllUnregisterServer (WINTRUST.@)
 953  */
 954 HRESULT WINAPI mssip32DllUnregisterServer(void)
 955 {
 956      FIXME("stub\n");
 957      return S_OK;
 958 }