26 Apr
2007
26 Apr
'07
1:38 p.m.
Author: winesync
Date: Thu Apr 26 17:38:13 2007
New Revision: 26520
URL: http://svn.reactos.org/svn/reactos?rev=26520&view=rev
Log:
Autosyncing with Wine HEAD
Added:
trunk/reactos/dll/win32/wintrust/crypt.c (with props)
Modified:
trunk/reactos/dll/win32/wintrust/register.c
trunk/reactos/dll/win32/wintrust/wintrust.rbuild
trunk/reactos/dll/win32/wintrust/wintrust.spec
trunk/reactos/dll/win32/wintrust/wintrust_main.c
trunk/reactos/dll/win32/wintrust/wintrust_ros.diff
Added: trunk/reactos/dll/win32/wintrust/crypt.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/wintrust/crypt.c…
==============================================================================
--- trunk/reactos/dll/win32/wintrust/crypt.c (added)
+++ trunk/reactos/dll/win32/wintrust/crypt.c Thu Apr 26 17:38:13 2007
@@ -1,0 +1,207 @@
+/*
+ * WinTrust Cryptography functions
+ *
+ * Copyright 2006 James Hawkins
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wintrust.h"
+#include "mscat.h"
+#include "mssip.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wintrust);
+
+/***********************************************************************
+ * CryptCATAdminAcquireContext (WINTRUST.@)
+ *
+ * Get a catalog administrator context handle.
+ *
+ * PARAMS
+ * catAdmin [O] Pointer to the context handle.
+ * sysSystem [I] Pointer to a GUID for the needed subsystem.
+ * dwFlags [I] Reserved.
+ *
+ * RETURNS
+ * Success: TRUE. catAdmin contains the context handle.
+ * Failure: FALSE.
+ *
+ */
+BOOL WINAPI CryptCATAdminAcquireContext(HCATADMIN* catAdmin,
+ const GUID *sysSystem, DWORD dwFlags )
+{
+ FIXME("%p %s %x\n", catAdmin, debugstr_guid(sysSystem), dwFlags);
+
+ if (catAdmin) *catAdmin = (HCATADMIN)0xdeadbeef;
+ return TRUE;
+}
+
+/***********************************************************************
+ * CryptCATAdminCalcHashFromFileHandle (WINTRUST.@)
+ */
+BOOL WINAPI CryptCATAdminCalcHashFromFileHandle(HANDLE hFile, DWORD* pcbHash,
+ BYTE* pbHash, DWORD dwFlags )
+{
+ FIXME("%p %p %p %x\n", hFile, pcbHash, pbHash, dwFlags);
+
+ if (pbHash && pcbHash) memset(pbHash, 0, *pcbHash);
+ return TRUE;
+}
+
+/***********************************************************************
+ * CryptCATAdminEnumCatalogFromHash (WINTRUST.@)
+ */
+HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash(HCATADMIN hCatAdmin,
+ BYTE* pbHash,
+ DWORD cbHash,
+ DWORD dwFlags,
+ HCATINFO* phPrevCatInfo )
+{
+ FIXME("%p %p %d %d %p\n", hCatAdmin, pbHash, cbHash, dwFlags,
phPrevCatInfo);
+ return NULL;
+}
+
+/***********************************************************************
+ * CryptCATAdminReleaseContext (WINTRUST.@)
+ *
+ * Release a catalog administrator context handle.
+ *
+ * PARAMS
+ * catAdmin [I] Context handle.
+ * dwFlags [I] Reserved.
+ *
+ * RETURNS
+ * Success: TRUE.
+ * Failure: FAIL.
+ *
+ */
+BOOL WINAPI CryptCATAdminReleaseContext(HCATADMIN hCatAdmin, DWORD dwFlags )
+{
+ FIXME("%p %x\n", hCatAdmin, dwFlags);
+ return TRUE;
+}
+
+/***********************************************************************
+ * CryptCATAdminRemoveCatalog (WINTRUST.@)
+ *
+ * Remove a catalog file.
+ *
+ * PARAMS
+ * catAdmin [I] Context handle.
+ * pwszCatalogFile [I] Catalog file.
+ * dwFlags [I] Reserved.
+ *
+ * RETURNS
+ * Success: TRUE.
+ * Failure: FALSE.
+ *
+ */
+BOOL WINAPI CryptCATAdminRemoveCatalog(HCATADMIN hCatAdmin, LPCWSTR pwszCatalogFile,
DWORD dwFlags)
+{
+ FIXME("%p %s %x\n", hCatAdmin, debugstr_w(pwszCatalogFile), dwFlags);
+ return DeleteFileW(pwszCatalogFile);
+}
+
+/***********************************************************************
+ * CryptCATClose (WINTRUST.@)
+ */
+BOOL WINAPI CryptCATClose(HANDLE hCatalog)
+{
+ FIXME("(%p) stub\n", hCatalog);
+ return TRUE;
+}
+
+/***********************************************************************
+ * CryptCATEnumerateMember (WINTRUST.@)
+ */
+CRYPTCATMEMBER *WINAPI CryptCATEnumerateMember(HANDLE hCatalog, CRYPTCATMEMBER*
pPrevMember)
+{
+ FIXME("(%p, %p) stub\n", hCatalog, pPrevMember);
+ return NULL;
+}
+
+/***********************************************************************
+ * CryptCATOpen (WINTRUST.@)
+ */
+HANDLE WINAPI CryptCATOpen(LPWSTR pwszFileName, DWORD fdwOpenFlags, HCRYPTPROV hProv,
+ DWORD dwPublicVersion, DWORD dwEncodingType)
+{
+ FIXME("(%s, %d, %ld, %d, %d) stub\n", debugstr_w(pwszFileName),
fdwOpenFlags,
+ hProv, dwPublicVersion, dwEncodingType);
+ return 0;
+}
+
+/***********************************************************************
+ * CryptSIPCreateIndirectData (WINTRUST.@)
+ */
+BOOL WINAPI CryptSIPCreateIndirectData(SIP_SUBJECTINFO* pSubjectInfo, DWORD*
pcbIndirectData,
+ SIP_INDIRECT_DATA* pIndirectData)
+{
+ FIXME("(%p %p %p) stub\n", pSubjectInfo, pcbIndirectData, pIndirectData);
+
+ return FALSE;
+}
+
+/***********************************************************************
+ * CryptSIPGetSignedDataMsg (WINTRUST.@)
+ */
+BOOL WINAPI CryptSIPGetSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD*
pdwEncodingType,
+ DWORD dwIndex, DWORD* pcbSignedDataMsg, BYTE*
pbSignedDataMsg)
+{
+ FIXME("(%p %p %d %p %p) stub\n", pSubjectInfo, pdwEncodingType, dwIndex,
+ pcbSignedDataMsg, pbSignedDataMsg);
+
+ return FALSE;
+}
+
+/***********************************************************************
+ * CryptSIPPutSignedDataMsg (WINTRUST.@)
+ */
+BOOL WINAPI CryptSIPPutSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD
pdwEncodingType,
+ DWORD* pdwIndex, DWORD cbSignedDataMsg, BYTE*
pbSignedDataMsg)
+{
+ FIXME("(%p %d %p %d %p) stub\n", pSubjectInfo, pdwEncodingType, pdwIndex,
+ cbSignedDataMsg, pbSignedDataMsg);
+
+ return FALSE;
+}
+
+/***********************************************************************
+ * CryptSIPRemoveSignedDataMsg (WINTRUST.@)
+ */
+BOOL WINAPI CryptSIPRemoveSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo,
+ DWORD dwIndex)
+{
+ FIXME("(%p %d) stub\n", pSubjectInfo, dwIndex);
+
+ return FALSE;
+}
+
+/***********************************************************************
+ * CryptSIPVerifyIndirectData (WINTRUST.@)
+ */
+BOOL WINAPI CryptSIPVerifyIndirectData(SIP_SUBJECTINFO* pSubjectInfo,
+ SIP_INDIRECT_DATA* pIndirectData)
+{
+ FIXME("(%p %p) stub\n", pSubjectInfo, pIndirectData);
+
+ return FALSE;
+}
Propchange: trunk/reactos/dll/win32/wintrust/crypt.c
------------------------------------------------------------------------------
svn:eol-style = native
Modified: trunk/reactos/dll/win32/wintrust/register.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/wintrust/registe…
==============================================================================
--- trunk/reactos/dll/win32/wintrust/register.c (original)
+++ trunk/reactos/dll/win32/wintrust/register.c Thu Apr 26 17:38:13 2007
@@ -23,104 +23,1063 @@
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
+#include "winuser.h"
+#include "winreg.h"
+#include "winnls.h"
#include "guiddef.h"
#include "wintrust.h"
#include "softpub.h"
+#include "mssip.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(wintrust);
+static CRYPT_TRUST_REG_ENTRY SoftpubInitialization;
+static CRYPT_TRUST_REG_ENTRY SoftpubMessage;
+static CRYPT_TRUST_REG_ENTRY SoftpubSignature;
+static CRYPT_TRUST_REG_ENTRY SoftpubCertficate;
+static CRYPT_TRUST_REG_ENTRY SoftpubCertCheck;
+static CRYPT_TRUST_REG_ENTRY SoftpubFinalPolicy;
+static CRYPT_TRUST_REG_ENTRY SoftpubCleanup;
+
+static CRYPT_TRUST_REG_ENTRY SoftpubDefCertInit;
+
+static CRYPT_TRUST_REG_ENTRY SoftpubDumpStructure;
+
+static CRYPT_TRUST_REG_ENTRY HTTPSCertificateTrust;
+static CRYPT_TRUST_REG_ENTRY HTTPSFinalProv;
+
+static CRYPT_TRUST_REG_ENTRY OfficeInitializePolicy;
+static CRYPT_TRUST_REG_ENTRY OfficeCleanupPolicy;
+
+static CRYPT_TRUST_REG_ENTRY DriverInitializePolicy;
+static CRYPT_TRUST_REG_ENTRY DriverFinalPolicy;
+static CRYPT_TRUST_REG_ENTRY DriverCleanupPolicy;
+
+static CRYPT_TRUST_REG_ENTRY GenericChainCertificateTrust;
+static CRYPT_TRUST_REG_ENTRY GenericChainFinalProv;
+
+static const WCHAR Trust[] =
{'S','o','f','t','w','a','r','e','\\',
+
'M','i','c','r','o','s','o','f','t','\\',
+
'C','r','y','p','t','o','g','r','a','p','h','y','\\',
+
'P','r','o','v','i','d','e','r','s','\\',
+
'T','r','u','s','t','\\', 0 };
+
+static const WCHAR Initialization[] =
{'I','n','i','t','i','a','l','i','z','a','t','i','o','n','\\',
0};
+static const WCHAR Message[] =
{'M','e','s','s','a','g','e','\\',
0};
+static const WCHAR Signature[] =
{'S','i','g','n','a','t','u','r','e','\\',
0};
+static const WCHAR Certificate[] =
{'C','e','r','t','i','f','i','c','a','t','e','\\',
0};
+static const WCHAR CertCheck[] =
{'C','e','r','t','C','h','e','c','k','\\',
0};
+static const WCHAR FinalPolicy[] =
{'F','i','n','a','l','P','o','l','i','c','y','\\',
0};
+static const WCHAR DiagnosticPolicy[] =
{'D','i','a','g','n','o','s','t','i','c','P','o','l','i','c','y','\\',
0};
+static const WCHAR Cleanup[] =
{'C','l','e','a','n','u','p','\\',
0};
+
+static const WCHAR DefaultId[] =
{'D','e','f','a','u','l','t','I','d',
0};
+static const WCHAR Dll[] = {'$','D','L','L',
0};
+
+/***********************************************************************
+ * WINTRUST_InitRegStructs
+ *
+ * Helper function to allocate and initialize the members of the
+ * CRYPT_TRUST_REG_ENTRY structs.
+ */
+static void WINTRUST_InitRegStructs(void)
+{
+#define WINTRUST_INITREGENTRY( action, dllname, functionname ) \
+ action.cbStruct = sizeof(CRYPT_TRUST_REG_ENTRY); \
+ action.pwszDLLName = HeapAlloc(GetProcessHeap(), 0, sizeof(dllname)); \
+ lstrcpyW(action.pwszDLLName, dllname); \
+ action.pwszFunctionName = HeapAlloc(GetProcessHeap(), 0, sizeof(functionname)); \
+ lstrcpyW(action.pwszFunctionName, functionname);
+
+ WINTRUST_INITREGENTRY(SoftpubInitialization, SP_POLICY_PROVIDER_DLL_NAME,
SP_INIT_FUNCTION)
+ WINTRUST_INITREGENTRY(SoftpubMessage, SP_POLICY_PROVIDER_DLL_NAME,
SP_OBJTRUST_FUNCTION)
+ WINTRUST_INITREGENTRY(SoftpubSignature, SP_POLICY_PROVIDER_DLL_NAME,
SP_SIGTRUST_FUNCTION)
+ WINTRUST_INITREGENTRY(SoftpubCertficate, SP_POLICY_PROVIDER_DLL_NAME,
WT_PROVIDER_CERTTRUST_FUNCTION)
+ WINTRUST_INITREGENTRY(SoftpubCertCheck, SP_POLICY_PROVIDER_DLL_NAME,
SP_CHKCERT_FUNCTION)
+ WINTRUST_INITREGENTRY(SoftpubFinalPolicy, SP_POLICY_PROVIDER_DLL_NAME,
SP_FINALPOLICY_FUNCTION)
+ WINTRUST_INITREGENTRY(SoftpubCleanup, SP_POLICY_PROVIDER_DLL_NAME,
SP_CLEANUPPOLICY_FUNCTION)
+ WINTRUST_INITREGENTRY(SoftpubDefCertInit, SP_POLICY_PROVIDER_DLL_NAME,
SP_GENERIC_CERT_INIT_FUNCTION)
+ WINTRUST_INITREGENTRY(SoftpubDumpStructure, SP_POLICY_PROVIDER_DLL_NAME,
SP_TESTDUMPPOLICY_FUNCTION_TEST)
+ WINTRUST_INITREGENTRY(HTTPSCertificateTrust, SP_POLICY_PROVIDER_DLL_NAME,
HTTPS_CERTTRUST_FUNCTION)
+ WINTRUST_INITREGENTRY(HTTPSFinalProv, SP_POLICY_PROVIDER_DLL_NAME,
HTTPS_FINALPOLICY_FUNCTION)
+ WINTRUST_INITREGENTRY(OfficeInitializePolicy, OFFICE_POLICY_PROVIDER_DLL_NAME,
OFFICE_INITPROV_FUNCTION)
+ WINTRUST_INITREGENTRY(OfficeCleanupPolicy, OFFICE_POLICY_PROVIDER_DLL_NAME,
OFFICE_CLEANUPPOLICY_FUNCTION)
+ WINTRUST_INITREGENTRY(DriverInitializePolicy, SP_POLICY_PROVIDER_DLL_NAME,
DRIVER_INITPROV_FUNCTION)
+ WINTRUST_INITREGENTRY(DriverFinalPolicy, SP_POLICY_PROVIDER_DLL_NAME,
DRIVER_FINALPOLPROV_FUNCTION)
+ WINTRUST_INITREGENTRY(DriverCleanupPolicy, SP_POLICY_PROVIDER_DLL_NAME,
DRIVER_CLEANUPPOLICY_FUNCTION)
+ WINTRUST_INITREGENTRY(GenericChainCertificateTrust, SP_POLICY_PROVIDER_DLL_NAME,
GENERIC_CHAIN_CERTTRUST_FUNCTION)
+ WINTRUST_INITREGENTRY(GenericChainFinalProv, SP_POLICY_PROVIDER_DLL_NAME,
GENERIC_CHAIN_FINALPOLICY_FUNCTION)
+
+#undef WINTRUST_INITREGENTRY
+}
+
+/***********************************************************************
+ * WINTRUST_FreeRegStructs
+ *
+ * Helper function to free 2 members of the CRYPT_TRUST_REG_ENTRY
+ * structs.
+ */
+static void WINTRUST_FreeRegStructs(void)
+{
+#define WINTRUST_FREEREGENTRY( action ) \
+ HeapFree(GetProcessHeap(), 0, action.pwszDLLName); \
+ HeapFree(GetProcessHeap(), 0, action.pwszFunctionName);
+
+ WINTRUST_FREEREGENTRY(SoftpubInitialization);
+ WINTRUST_FREEREGENTRY(SoftpubMessage);
+ WINTRUST_FREEREGENTRY(SoftpubSignature);
+ WINTRUST_FREEREGENTRY(SoftpubCertficate);
+ WINTRUST_FREEREGENTRY(SoftpubCertCheck);
+ WINTRUST_FREEREGENTRY(SoftpubFinalPolicy);
+ WINTRUST_FREEREGENTRY(SoftpubCleanup);
+ WINTRUST_FREEREGENTRY(SoftpubDefCertInit);
+ WINTRUST_FREEREGENTRY(SoftpubDumpStructure);
+ WINTRUST_FREEREGENTRY(HTTPSCertificateTrust);
+ WINTRUST_FREEREGENTRY(HTTPSFinalProv);
+ WINTRUST_FREEREGENTRY(OfficeInitializePolicy);
+ WINTRUST_FREEREGENTRY(OfficeCleanupPolicy);
+ WINTRUST_FREEREGENTRY(DriverInitializePolicy);
+ WINTRUST_FREEREGENTRY(DriverFinalPolicy);
+ WINTRUST_FREEREGENTRY(DriverCleanupPolicy);
+ WINTRUST_FREEREGENTRY(GenericChainCertificateTrust);
+ WINTRUST_FREEREGENTRY(GenericChainFinalProv);
+
+#undef WINTRUST_FREEREGENTRY
+}
+
+/***********************************************************************
+ * WINTRUST_guid2wstr
+ *
+ * Create a wide-string from a GUID
+ *
+ */
+static void WINTRUST_Guid2Wstr(const GUID* pgActionID, WCHAR* GuidString)
+{
+ static const WCHAR wszFormat[] =
{'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
+
'%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
+
'X','%','0','2','X','%','0','2','X','}',
0};
+
+ wsprintfW(GuidString, wszFormat, pgActionID->Data1, pgActionID->Data2,
pgActionID->Data3,
+ pgActionID->Data4[0], pgActionID->Data4[1], pgActionID->Data4[2],
pgActionID->Data4[3],
+ pgActionID->Data4[4], pgActionID->Data4[5], pgActionID->Data4[6],
pgActionID->Data4[7]);
+}
+
+/***********************************************************************
+ * WINTRUST_WriteProviderToReg
+ *
+ * Helper function for WintrustAddActionID
+ *
+ */
+static LONG WINTRUST_WriteProviderToReg(WCHAR* GuidString,
+ const WCHAR* FunctionType,
+ CRYPT_TRUST_REG_ENTRY RegEntry)
+{
+ static const WCHAR Function[] =
{'$','F','u','n','c','t','i','o','n',
0};
+ WCHAR ProvKey[MAX_PATH];
+ HKEY Key;
+ LONG Res = ERROR_SUCCESS;
+
+ /* Create the needed key string */
+ ProvKey[0]='\0';
+ lstrcatW(ProvKey, Trust);
+ lstrcatW(ProvKey, FunctionType);
+ lstrcatW(ProvKey, GuidString);
+
+ if (!RegEntry.pwszDLLName || !RegEntry.pwszFunctionName)
+ return ERROR_INVALID_PARAMETER;
+
+ Res = RegCreateKeyExW(HKEY_LOCAL_MACHINE, ProvKey, 0, NULL, 0, KEY_WRITE, NULL,
&Key, NULL);
+ if (Res != ERROR_SUCCESS) goto error_close_key;
+
+ /* Create the $DLL entry */
+ Res = RegSetValueExW(Key, Dll, 0, REG_SZ, (BYTE*)RegEntry.pwszDLLName,
+ (lstrlenW(RegEntry.pwszDLLName) + 1)*sizeof(WCHAR));
+ if (Res != ERROR_SUCCESS) goto error_close_key;
+
+ /* Create the $Function entry */
+ Res = RegSetValueExW(Key, Function, 0, REG_SZ, (BYTE*)RegEntry.pwszFunctionName,
+ (lstrlenW(RegEntry.pwszFunctionName) + 1)*sizeof(WCHAR));
+
+error_close_key:
+ RegCloseKey(Key);
+
+ return Res;
+}
+
/***********************************************************************
* WintrustAddActionID (WINTRUST.@)
+ *
+ * Add the definitions of the actions a Trust provider can perform to
+ * the registry.
+ *
+ * PARAMS
+ * pgActionID [I] Pointer to a GUID for the Trust provider.
+ * fdwFlags [I] Flag to indicate whether registry errors are passed on.
+ * psProvInfo [I] Pointer to a structure with information about DLL
+ * name and functions.
+ *
+ * RETURNS
+ * Success: TRUE.
+ * Failure: FALSE. (Use GetLastError() for more information)
+ *
+ * NOTES
+ * Adding definitions is basically only adding relevant information
+ * to the registry. No verification takes place whether a DLL or it's
+ * entrypoints exist.
+ * Information in the registry will always be overwritten.
+ *
*/
BOOL WINAPI WintrustAddActionID( GUID* pgActionID, DWORD fdwFlags,
CRYPT_REGISTER_ACTIONID* psProvInfo)
{
- FIXME("%p %lx %p\n", pgActionID, fdwFlags, psProvInfo);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ WCHAR GuidString[39];
+ LONG Res;
+ LONG WriteActionError = ERROR_SUCCESS;
+
+ TRACE("%s %x %p\n", debugstr_guid(pgActionID), fdwFlags, psProvInfo);
+
+ /* Some sanity checks.
+ * We use the W2K3 last error as it makes more sense (W2K leaves the last error
+ * as is).
+ */
+ if (!pgActionID ||
+ !psProvInfo ||
+ (psProvInfo->cbStruct != sizeof(CRYPT_REGISTER_ACTIONID)))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+ /* Create this string only once, instead of in the helper function */
+ WINTRUST_Guid2Wstr( pgActionID, GuidString);
+
+ /* Write the information to the registry */
+ Res = WINTRUST_WriteProviderToReg(GuidString, Initialization ,
psProvInfo->sInitProvider);
+ if (Res != ERROR_SUCCESS) WriteActionError = Res;
+ Res = WINTRUST_WriteProviderToReg(GuidString, Message ,
psProvInfo->sObjectProvider);
+ if (Res != ERROR_SUCCESS) WriteActionError = Res;
+ Res = WINTRUST_WriteProviderToReg(GuidString, Signature ,
psProvInfo->sSignatureProvider);
+ if (Res != ERROR_SUCCESS) WriteActionError = Res;
+ Res = WINTRUST_WriteProviderToReg(GuidString, Certificate ,
psProvInfo->sCertificateProvider);
+ if (Res != ERROR_SUCCESS) WriteActionError = Res;
+ Res = WINTRUST_WriteProviderToReg(GuidString, CertCheck ,
psProvInfo->sCertificatePolicyProvider);
+ if (Res != ERROR_SUCCESS) WriteActionError = Res;
+ Res = WINTRUST_WriteProviderToReg(GuidString, FinalPolicy ,
psProvInfo->sFinalPolicyProvider);
+ if (Res != ERROR_SUCCESS) WriteActionError = Res;
+ Res = WINTRUST_WriteProviderToReg(GuidString, DiagnosticPolicy,
psProvInfo->sTestPolicyProvider);
+ if (Res != ERROR_SUCCESS) WriteActionError = Res;
+ Res = WINTRUST_WriteProviderToReg(GuidString, Cleanup ,
psProvInfo->sCleanupProvider);
+ if (Res != ERROR_SUCCESS) WriteActionError = Res;
+
+ /* Testing (by restricting access to the registry for some keys) shows that the last
failing function
+ * will be used for last error.
+ * If the flag WT_ADD_ACTION_ID_RET_RESULT_FLAG is set and there are errors when
adding the action
+ * we have to return FALSE. Errors includes both invalid entries as well as registry
errors.
+ * Testing also showed that one error doesn't stop the registry writes. Every
action will be dealt with.
+ */
+
+ if (WriteActionError != ERROR_SUCCESS)
+ {
+ SetLastError(WriteActionError);
+
+ if (fdwFlags == WT_ADD_ACTION_ID_RET_RESULT_FLAG)
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/***********************************************************************
+ * WINTRUST_RemoveProviderFromReg
+ *
+ * Helper function for WintrustRemoveActionID
+ *
+ */
+static void WINTRUST_RemoveProviderFromReg(WCHAR* GuidString,
+ const WCHAR* FunctionType)
+{
+ WCHAR ProvKey[MAX_PATH];
+
+ /* Create the needed key string */
+ ProvKey[0]='\0';
+ lstrcatW(ProvKey, Trust);
+ lstrcatW(ProvKey, FunctionType);
+ lstrcatW(ProvKey, GuidString);
+
+ /* We don't care about success or failure */
+ RegDeleteKeyW(HKEY_LOCAL_MACHINE, ProvKey);
}
/***********************************************************************
* WintrustRemoveActionID (WINTRUST.@)
+ *
+ * Remove the definitions of the actions a Trust provider can perform
+ * from the registry.
+ *
+ * PARAMS
+ * pgActionID [I] Pointer to a GUID for the Trust provider.
+ *
+ * RETURNS
+ * Success: TRUE. (Use GetLastError() for more information)
+ * Failure: FALSE. (Use GetLastError() for more information)
+ *
+ * NOTES
+ * Testing shows that WintrustRemoveActionID always returns TRUE and
+ * that a possible error should be retrieved via GetLastError().
+ * There are no checks if the definitions are in the registry.
*/
BOOL WINAPI WintrustRemoveActionID( GUID* pgActionID )
{
- FIXME("(%s)\n", debugstr_guid(pgActionID));
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ WCHAR GuidString[39];
+
+ TRACE("(%s)\n", debugstr_guid(pgActionID));
+
+ if (!pgActionID)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return TRUE;
+ }
+
+ /* Create this string only once, instead of in the helper function */
+ WINTRUST_Guid2Wstr( pgActionID, GuidString);
+
+ /* We don't care about success or failure */
+ WINTRUST_RemoveProviderFromReg(GuidString, Initialization);
+ WINTRUST_RemoveProviderFromReg(GuidString, Message);
+ WINTRUST_RemoveProviderFromReg(GuidString, Signature);
+ WINTRUST_RemoveProviderFromReg(GuidString, Certificate);
+ WINTRUST_RemoveProviderFromReg(GuidString, CertCheck);
+ WINTRUST_RemoveProviderFromReg(GuidString, FinalPolicy);
+ WINTRUST_RemoveProviderFromReg(GuidString, DiagnosticPolicy);
+ WINTRUST_RemoveProviderFromReg(GuidString, Cleanup);
+
+ return TRUE;
+}
+
+/***********************************************************************
+ * WINTRUST_WriteSingleUsageEntry
+ *
+ * Helper for WintrustAddDefaultForUsage, writes a single value and its
+ * data to:
+ *
+ * HKLM\Software\Microsoft\Cryptography\Trust\Usages\<OID>
+ */
+static LONG WINTRUST_WriteSingleUsageEntry(LPCSTR OID,
+ const WCHAR* Value,
+ WCHAR* Data)
+{
+ static const WCHAR Usages[] =
{'U','s','a','g','e','s','\\',
0};
+ WCHAR* UsageKey;
+ HKEY Key;
+ LONG Res = ERROR_SUCCESS;
+ WCHAR* OIDW;
+ DWORD Len;
+
+ /* Turn OID into a wide-character string */
+ Len = MultiByteToWideChar( CP_ACP, 0, OID, -1, NULL, 0 );
+ OIDW = HeapAlloc( GetProcessHeap(), 0, Len * sizeof(WCHAR) );
+ MultiByteToWideChar( CP_ACP, 0, OID, -1, OIDW, Len );
+
+ /* Allocate the needed space for UsageKey */
+ UsageKey = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(Trust) + lstrlenW(Usages) + Len)
* sizeof(WCHAR));
+ /* Create the key string */
+ lstrcpyW(UsageKey, Trust);
+ lstrcatW(UsageKey, Usages);
+ lstrcatW(UsageKey, OIDW);
+
+ Res = RegCreateKeyExW(HKEY_LOCAL_MACHINE, UsageKey, 0, NULL, 0, KEY_WRITE, NULL,
&Key, NULL);
+ if (Res == ERROR_SUCCESS)
+ {
+ /* Create the Value entry */
+ Res = RegSetValueExW(Key, Value, 0, REG_SZ, (BYTE*)Data,
+ (lstrlenW(Data) + 1)*sizeof(WCHAR));
+ }
+ RegCloseKey(Key);
+
+ HeapFree(GetProcessHeap(), 0, OIDW);
+ HeapFree(GetProcessHeap(), 0, UsageKey);
+
+ return Res;
+}
+
+/***************************************************************************
+ * WINTRUST_RegisterGenVerifyV2
+ *
+ * Register WINTRUST_ACTION_GENERIC_VERIFY_V2 actions and usages.
+ *
+ * NOTES
+ * WINTRUST_ACTION_GENERIC_VERIFY_V2 ({00AAC56B-CD44-11D0-8CC2-00C04FC295EE}
+ * is defined in softpub.h
+ */
+static BOOL WINTRUST_RegisterGenVerifyV2(void)
+{
+ BOOL RegisteredOK = TRUE;
+ static GUID ProvGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
+ CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
+ SoftpubInitialization,
+ SoftpubMessage,
+ SoftpubSignature,
+ SoftpubCertficate,
+ SoftpubCertCheck,
+ SoftpubFinalPolicy,
+ { 0, NULL, NULL }, /* No diagnostic policy */
+ SoftpubCleanup };
+ CRYPT_PROVIDER_REGDEFUSAGE DefUsage = { sizeof(CRYPT_PROVIDER_REGDEFUSAGE),
+ &ProvGUID,
+ NULL, /* No Dll provided */
+ NULL, /* No load callback function */
+ NULL }; /* No free callback function */
+
+ if (!WintrustAddDefaultForUsage(szOID_PKIX_KP_CODE_SIGNING, &DefUsage))
+ RegisteredOK = FALSE;
+
+ if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
+ RegisteredOK = FALSE;
+
+ return RegisteredOK;
+}
+
+/***************************************************************************
+ * WINTRUST_RegisterPublishedSoftware
+ *
+ * Register WIN_SPUB_ACTION_PUBLISHED_SOFTWARE actions and usages.
+ *
+ * NOTES
+ * WIN_SPUB_ACTION_PUBLISHED_SOFTWARE ({64B9D180-8DA2-11CF-8736-00AA00A485EB})
+ * is defined in wintrust.h
+ */
+static BOOL WINTRUST_RegisterPublishedSoftware(void)
+{
+ static GUID ProvGUID = WIN_SPUB_ACTION_PUBLISHED_SOFTWARE;
+ CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
+ SoftpubInitialization,
+ SoftpubMessage,
+ SoftpubSignature,
+ SoftpubCertficate,
+ SoftpubCertCheck,
+ SoftpubFinalPolicy,
+ { 0, NULL, NULL }, /* No diagnostic policy */
+ SoftpubCleanup };
+
+ if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
+ return FALSE;
+
+ return TRUE;
+}
+
+#define WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI { 0xc6b2e8d0, 0xe005, 0x11cf, {
0xa1,0x34,0x00,0xc0,0x4f,0xd7,0xbf,0x43 }}
+
+/***************************************************************************
+ * WINTRUST_RegisterPublishedSoftwareNoBadUi
+ *
+ * Register WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI actions and usages.
+ *
+ * NOTES
+ * WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI ({C6B2E8D0-E005-11CF-A134-00C04FD7BF43})
+ * is not defined in any include file. (FIXME: Find out if the name is correct).
+ */
+static BOOL WINTRUST_RegisterPublishedSoftwareNoBadUi(void)
+{
+ static GUID ProvGUID = WIN_SPUB_ACTION_PUBLISHED_SOFTWARE_NOBADUI;
+ CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
+ SoftpubInitialization,
+ SoftpubMessage,
+ SoftpubSignature,
+ SoftpubCertficate,
+ SoftpubCertCheck,
+ SoftpubFinalPolicy,
+ { 0, NULL, NULL }, /* No diagnostic policy */
+ SoftpubCleanup };
+
+ if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
+ return FALSE;
+
+ return TRUE;
+}
+
+/***************************************************************************
+ * WINTRUST_RegisterGenCertVerify
+ *
+ * Register WINTRUST_ACTION_GENERIC_CERT_VERIFY actions and usages.
+ *
+ * NOTES
+ * WINTRUST_ACTION_GENERIC_CERT_VERIFY ({189A3842-3041-11D1-85E1-00C04FC295EE})
+ * is defined in softpub.h
+ */
+static BOOL WINTRUST_RegisterGenCertVerify(void)
+{
+ static GUID ProvGUID = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
+ CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
+ SoftpubDefCertInit,
+ SoftpubMessage,
+ SoftpubSignature,
+ SoftpubCertficate,
+ SoftpubCertCheck,
+ SoftpubFinalPolicy,
+ { 0, NULL, NULL }, /* No diagnostic policy */
+ SoftpubCleanup };
+
+ if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
+ return FALSE;
+
+ return TRUE;
+}
+
+/***************************************************************************
+ * WINTRUST_RegisterTrustProviderTest
+ *
+ * Register WINTRUST_ACTION_TRUSTPROVIDER_TEST actions and usages.
+ *
+ * NOTES
+ * WINTRUST_ACTION_TRUSTPROVIDER_TEST ({573E31F8-DDBA-11D0-8CCB-00C04FC295EE})
+ * is defined in softpub.h
+ */
+static BOOL WINTRUST_RegisterTrustProviderTest(void)
+{
+ static GUID ProvGUID = WINTRUST_ACTION_TRUSTPROVIDER_TEST;
+ CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
+ SoftpubInitialization,
+ SoftpubMessage,
+ SoftpubSignature,
+ SoftpubCertficate,
+ SoftpubCertCheck,
+ SoftpubFinalPolicy,
+ SoftpubDumpStructure,
+ SoftpubCleanup };
+
+ if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
+ return FALSE;
+
+ return TRUE;
+}
+
+/***************************************************************************
+ * WINTRUST_RegisterHttpsProv
+ *
+ * Register HTTPSPROV_ACTION actions and usages.
+ *
+ * NOTES
+ * HTTPSPROV_ACTION ({573E31F8-AABA-11D0-8CCB-00C04FC295EE})
+ * is defined in softpub.h
+ */
+static BOOL WINTRUST_RegisterHttpsProv(void)
+{
+ BOOL RegisteredOK = TRUE;
+ static CHAR SoftpubLoadUsage[] = "SoftpubLoadDefUsageCallData";
+ static CHAR SoftpubFreeUsage[] = "SoftpubFreeDefUsageCallData";
+ static GUID ProvGUID = HTTPSPROV_ACTION;
+ CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
+ SoftpubInitialization,
+ SoftpubMessage,
+ SoftpubSignature,
+ HTTPSCertificateTrust,
+ SoftpubCertCheck,
+ HTTPSFinalProv,
+ { 0, NULL, NULL }, /* No diagnostic policy */
+ SoftpubCleanup };
+ CRYPT_PROVIDER_REGDEFUSAGE DefUsage = { sizeof(CRYPT_PROVIDER_REGDEFUSAGE),
+ &ProvGUID,
+ NULL, /* Will be filled later */
+ SoftpubLoadUsage,
+ SoftpubFreeUsage };
+
+ DefUsage.pwszDllName = HeapAlloc(GetProcessHeap(), 0,
sizeof(SP_POLICY_PROVIDER_DLL_NAME));
+ lstrcpyW(DefUsage.pwszDllName, SP_POLICY_PROVIDER_DLL_NAME);
+
+ if (!WintrustAddDefaultForUsage(szOID_PKIX_KP_SERVER_AUTH, &DefUsage))
+ RegisteredOK = FALSE;
+ if (!WintrustAddDefaultForUsage(szOID_PKIX_KP_CLIENT_AUTH, &DefUsage))
+ RegisteredOK = FALSE;
+ if (!WintrustAddDefaultForUsage(szOID_SERVER_GATED_CRYPTO, &DefUsage))
+ RegisteredOK = FALSE;
+ if (!WintrustAddDefaultForUsage(szOID_SGC_NETSCAPE, &DefUsage))
+ RegisteredOK = FALSE;
+
+ HeapFree(GetProcessHeap(), 0, DefUsage.pwszDllName);
+
+ if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
+ RegisteredOK = FALSE;
+
+ return RegisteredOK;
+}
+
+/***************************************************************************
+ * WINTRUST_RegisterOfficeSignVerify
+ *
+ * Register OFFICESIGN_ACTION_VERIFY actions and usages.
+ *
+ * NOTES
+ * OFFICESIGN_ACTION_VERIFY ({5555C2CD-17FB-11D1-85C4-00C04FC295EE})
+ * is defined in softpub.h
+ */
+static BOOL WINTRUST_RegisterOfficeSignVerify(void)
+{
+ static GUID ProvGUID = OFFICESIGN_ACTION_VERIFY;
+ CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
+ OfficeInitializePolicy,
+ SoftpubMessage,
+ SoftpubSignature,
+ SoftpubCertficate,
+ SoftpubCertCheck,
+ SoftpubFinalPolicy,
+ { 0, NULL, NULL }, /* No diagnostic policy */
+ OfficeCleanupPolicy };
+
+ if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
+ return FALSE;
+
+ return TRUE;
+}
+
+/***************************************************************************
+ * WINTRUST_RegisterDriverVerify
+ *
+ * Register DRIVER_ACTION_VERIFY actions and usages.
+ *
+ * NOTES
+ * DRIVER_ACTION_VERIFY ({F750E6C3-38EE-11D1-85E5-00C04FC295EE})
+ * is defined in softpub.h
+ */
+static BOOL WINTRUST_RegisterDriverVerify(void)
+{
+ static GUID ProvGUID = DRIVER_ACTION_VERIFY;
+ CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
+ DriverInitializePolicy,
+ SoftpubMessage,
+ SoftpubSignature,
+ SoftpubCertficate,
+ SoftpubCertCheck,
+ DriverFinalPolicy,
+ { 0, NULL, NULL }, /* No diagnostic policy */
+ DriverCleanupPolicy };
+
+ if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
+ return FALSE;
+
+ return TRUE;
+}
+
+/***************************************************************************
+ * WINTRUST_RegisterGenChainVerify
+ *
+ * Register WINTRUST_ACTION_GENERIC_CHAIN_VERIFY actions and usages.
+ *
+ * NOTES
+ * WINTRUST_ACTION_GENERIC_CHAIN_VERIFY ({FC451C16-AC75-11D1-B4B8-00C04FB66EA0})
+ * is defined in softpub.h
+ */
+static BOOL WINTRUST_RegisterGenChainVerify(void)
+{
+ static GUID ProvGUID = WINTRUST_ACTION_GENERIC_CHAIN_VERIFY;
+ CRYPT_REGISTER_ACTIONID ProvInfo = { sizeof(CRYPT_REGISTER_ACTIONID),
+ SoftpubInitialization,
+ SoftpubMessage,
+ SoftpubSignature,
+ GenericChainCertificateTrust,
+ SoftpubCertCheck,
+ GenericChainFinalProv,
+ { 0, NULL, NULL }, /* No diagnostic policy */
+ SoftpubCleanup };
+
+ if (!WintrustAddActionID(&ProvGUID, 0, &ProvInfo))
+ return FALSE;
+
+ return TRUE;
+}
+
+/***********************************************************************
+ * WintrustAddDefaultForUsage (WINTRUST.@)
+ *
+ * Write OID and callback functions to the registry.
+ *
+ * PARAMS
+ * pszUsageOID [I] Pointer to a GUID.
+ * psDefUsage [I] Pointer to a structure that specifies the callback functions.
+ *
+ * RETURNS
+ * Success: TRUE.
+ * Failure: FALSE.
+ *
+ * NOTES
+ * WintrustAddDefaultForUsage will only return TRUE or FALSE, no last
+ * error is set, not even when the registry cannot be written to.
+ */
+BOOL WINAPI WintrustAddDefaultForUsage(const char *pszUsageOID,
+ CRYPT_PROVIDER_REGDEFUSAGE *psDefUsage)
+{
+ 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};
+ 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};
+ LONG Res = ERROR_SUCCESS;
+ LONG WriteUsageError = ERROR_SUCCESS;
+ DWORD Len;
+ WCHAR GuidString[39];
+
+ TRACE("(%s %p)\n", debugstr_a(pszUsageOID), psDefUsage);
+
+ /* Some sanity checks. */
+ if (!pszUsageOID ||
+ !psDefUsage ||
+ !psDefUsage->pgActionID ||
+ (psDefUsage->cbStruct != sizeof(CRYPT_PROVIDER_REGDEFUSAGE)))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+ if (psDefUsage->pwszDllName)
+ {
+ Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, Dll,
psDefUsage->pwszDllName);
+ if (Res != ERROR_SUCCESS) WriteUsageError = Res;
+ }
+ if (psDefUsage->pwszLoadCallbackDataFunctionName)
+ {
+ WCHAR* CallbackW;
+
+ Len = MultiByteToWideChar( CP_ACP, 0,
psDefUsage->pwszLoadCallbackDataFunctionName, -1, NULL, 0 );
+ CallbackW = HeapAlloc( GetProcessHeap(), 0, Len * sizeof(WCHAR) );
+ MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszLoadCallbackDataFunctionName,
-1, CallbackW, Len );
+
+ Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, CBAlloc, CallbackW);
+ if (Res != ERROR_SUCCESS) WriteUsageError = Res;
+
+ HeapFree(GetProcessHeap(), 0, CallbackW);
+ }
+ if (psDefUsage->pwszFreeCallbackDataFunctionName)
+ {
+ WCHAR* CallbackW;
+
+ Len = MultiByteToWideChar( CP_ACP, 0,
psDefUsage->pwszFreeCallbackDataFunctionName, -1, NULL, 0 );
+ CallbackW = HeapAlloc( GetProcessHeap(), 0, Len * sizeof(WCHAR) );
+ MultiByteToWideChar( CP_ACP, 0, psDefUsage->pwszFreeCallbackDataFunctionName,
-1, CallbackW, Len );
+
+ Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, CBFree, CallbackW);
+ if (Res != ERROR_SUCCESS) WriteUsageError = Res;
+
+ HeapFree(GetProcessHeap(), 0, CallbackW);
+ }
+
+ WINTRUST_Guid2Wstr(psDefUsage->pgActionID, GuidString);
+ Res = WINTRUST_WriteSingleUsageEntry(pszUsageOID, DefaultId, GuidString);
+ if (Res != ERROR_SUCCESS) WriteUsageError = Res;
+
+ if (WriteUsageError != ERROR_SUCCESS)
+ return FALSE;
+
+ return TRUE;
+}
+
+/***********************************************************************
+ * WINTRUST_SIPPAddProvider
+ *
+ * Helper for DllRegisterServer.
+ */
+static BOOL WINTRUST_SIPPAddProvider(GUID* Subject, WCHAR* MagicNumber)
+{
+ static WCHAR CryptSIPGetSignedDataMsg[] =
+
{'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};
+ static WCHAR CryptSIPPutSignedDataMsg[] =
+
{'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};
+ static WCHAR CryptSIPCreateIndirectData[] =
+
{'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};
+ static WCHAR CryptSIPVerifyIndirectData[] =
+
{'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};
+ static WCHAR CryptSIPRemoveSignedDataMsg[] =
+
{'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};
+ SIP_ADD_NEWPROVIDER NewProv;
+ BOOL Ret;
+
+ /* Clear and initialize the structure */
+ memset(&NewProv, 0, sizeof(SIP_ADD_NEWPROVIDER));
+ NewProv.cbStruct = sizeof(SIP_ADD_NEWPROVIDER);
+ NewProv.pwszDLLFileName = HeapAlloc(GetProcessHeap(), 0,
sizeof(SP_POLICY_PROVIDER_DLL_NAME));
+ /* Fill the structure */
+ NewProv.pgSubject = Subject;
+ lstrcpyW(NewProv.pwszDLLFileName, SP_POLICY_PROVIDER_DLL_NAME);
+ NewProv.pwszMagicNumber = MagicNumber;
+ NewProv.pwszIsFunctionName = NULL;
+ NewProv.pwszGetFuncName = CryptSIPGetSignedDataMsg;
+ NewProv.pwszPutFuncName = CryptSIPPutSignedDataMsg;
+ NewProv.pwszCreateFuncName = CryptSIPCreateIndirectData;
+ NewProv.pwszVerifyFuncName = CryptSIPVerifyIndirectData;
+ NewProv.pwszRemoveFuncName = CryptSIPRemoveSignedDataMsg;
+ NewProv.pwszIsFunctionNameFmt2 = NULL;
+
+ Ret = CryptSIPAddProvider(&NewProv);
+
+ HeapFree(GetProcessHeap(), 0, NewProv.pwszDLLFileName);
+
+ return Ret;
}
/***********************************************************************
* DllRegisterServer (WINTRUST.@)
*/
HRESULT WINAPI DllRegisterServer(void)
+{
+ static const CHAR SpcPeImageDataEncode[] =
"WVTAsn1SpcPeImageDataEncode";
+ static const CHAR SpcPeImageDataDecode[] =
"WVTAsn1SpcPeImageDataDecode";
+ static const CHAR SpcLinkEncode[] =
"WVTAsn1SpcLinkEncode";
+ static const CHAR SpcLinkDecode[] =
"WVTAsn1SpcLinkDecode";
+ static const CHAR SpcSigInfoEncode[] =
"WVTAsn1SpcSigInfoEncode";
+ static const CHAR SpcSigInfoDecode[] =
"WVTAsn1SpcSigInfoDecode";
+ static const CHAR SpcIndirectDataContentEncode[] =
"WVTAsn1SpcIndirectDataContentEncode";
+ static const CHAR SpcIndirectDataContentDecode[] =
"WVTAsn1SpcIndirectDataContentDecode";
+ static const CHAR SpcSpAgencyInfoEncode[] =
"WVTAsn1SpcSpAgencyInfoEncode";
+ static const CHAR SpcSpAgencyInfoDecode[] =
"WVTAsn1SpcSpAgencyInfoDecode";
+ static const CHAR SpcMinimalCriteriaInfoEncode[] =
"WVTAsn1SpcMinimalCriteriaInfoEncode";
+ static const CHAR SpcMinimalCriteriaInfoDecode[] =
"WVTAsn1SpcMinimalCriteriaInfoDecode";
+ static const CHAR SpcFinancialCriteriaInfoEncode[] =
"WVTAsn1SpcFinancialCriteriaInfoEncode";
+ static const CHAR SpcFinancialCriteriaInfoDecode[] =
"WVTAsn1SpcFinancialCriteriaInfoDecode";
+ static const CHAR SpcStatementTypeEncode[] =
"WVTAsn1SpcStatementTypeEncode";
+ static const CHAR SpcStatementTypeDecode[] =
"WVTAsn1SpcStatementTypeDecode";
+ static const CHAR CatNameValueEncode[] =
"WVTAsn1CatNameValueEncode";
+ static const CHAR CatNameValueDecode[] =
"WVTAsn1CatNameValueDecode";
+ static const CHAR CatMemberInfoEncode[] =
"WVTAsn1CatMemberInfoEncode";
+ static const CHAR CatMemberInfoDecode[] =
"WVTAsn1CatMemberInfoDecode";
+ static const CHAR SpcSpOpusInfoEncode[] =
"WVTAsn1SpcSpOpusInfoEncode";
+ static const CHAR SpcSpOpusInfoDecode[] =
"WVTAsn1SpcSpOpusInfoDecode";
+ static GUID Unknown1 = { 0xDE351A42, 0x8E59, 0x11D0, {
0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
+ static GUID Unknown2 = { 0xC689AABA, 0x8E78, 0x11D0, {
0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
+ static GUID Unknown3 = { 0xC689AAB8, 0x8E78, 0x11D0, {
0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
+ static GUID Unknown4 = { 0xC689AAB9, 0x8E78, 0x11D0, {
0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
+ static GUID Unknown5 = { 0xDE351A43, 0x8E59, 0x11D0, {
0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
+ static GUID Unknown6 = { 0x9BA61D3F, 0xE73A, 0x11D0, {
0x8C,0xD2,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
+ static WCHAR MagicNumber2[] = {'M','S','C','F', 0};
+ static WCHAR MagicNumber3[] =
{'0','x','0','0','0','0','4','5','5','0',
0};
+ static WCHAR CafeBabe[] =
{'0','x','c','a','f','e','b','a','b','e',
0};
+
+ HRESULT CryptRegisterRes = S_OK;
+ HRESULT TrustProviderRes = S_OK;
+ HRESULT SIPAddProviderRes = S_OK;
+
+ TRACE("\n");
+
+ /* Testing on native shows that when an error is encountered in one of the
CryptRegisterOIDFunction calls
+ * the rest of these calls is skipped. Registering is however continued for the trust
providers.
+ *
+ * We are not totally in line with native as there all decoding functions are
registered after all encoding
+ * functions.
+ */
+#define WINTRUST_REGISTEROID( oid, encode_funcname, decode_funcname ) \
+ do { \
+ if (!CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_ENCODE_OBJECT_FUNC,
oid, SP_POLICY_PROVIDER_DLL_NAME, encode_funcname)) \
+ { \
+ CryptRegisterRes = HRESULT_FROM_WIN32(GetLastError()); \
+ goto add_trust_providers; \
+ } \
+ if (!CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_DECODE_OBJECT_FUNC,
oid, SP_POLICY_PROVIDER_DLL_NAME, decode_funcname)) \
+ { \
+ CryptRegisterRes = HRESULT_FROM_WIN32(GetLastError()); \
+ goto add_trust_providers; \
+ } \
+ } while (0)
+
+ WINTRUST_REGISTEROID(SPC_PE_IMAGE_DATA_OBJID, SpcPeImageDataEncode,
SpcPeImageDataDecode);
+ WINTRUST_REGISTEROID(SPC_PE_IMAGE_DATA_STRUCT, SpcPeImageDataEncode,
SpcPeImageDataDecode);
+ WINTRUST_REGISTEROID(SPC_CAB_DATA_OBJID, SpcLinkEncode, SpcLinkDecode);
+ WINTRUST_REGISTEROID(SPC_CAB_DATA_STRUCT, SpcLinkEncode, SpcLinkDecode);
+ WINTRUST_REGISTEROID(SPC_JAVA_CLASS_DATA_OBJID, SpcLinkEncode, SpcLinkDecode);
+ WINTRUST_REGISTEROID(SPC_JAVA_CLASS_DATA_STRUCT, SpcLinkEncode, SpcLinkDecode);
+ WINTRUST_REGISTEROID(SPC_LINK_OBJID, SpcLinkEncode, SpcLinkDecode);
+ WINTRUST_REGISTEROID(SPC_LINK_STRUCT, SpcLinkEncode, SpcLinkDecode);
+ WINTRUST_REGISTEROID(SPC_SIGINFO_OBJID, SpcSigInfoEncode, SpcSigInfoDecode);
+ WINTRUST_REGISTEROID(SPC_SIGINFO_STRUCT, SpcSigInfoEncode, SpcSigInfoDecode);
+ WINTRUST_REGISTEROID(SPC_INDIRECT_DATA_OBJID, SpcIndirectDataContentEncode,
SpcIndirectDataContentDecode);
+ WINTRUST_REGISTEROID(SPC_INDIRECT_DATA_CONTENT_STRUCT, SpcIndirectDataContentEncode,
SpcIndirectDataContentDecode);
+ WINTRUST_REGISTEROID(SPC_SP_AGENCY_INFO_OBJID, SpcSpAgencyInfoEncode,
SpcSpAgencyInfoDecode);
+ WINTRUST_REGISTEROID(SPC_SP_AGENCY_INFO_STRUCT, SpcSpAgencyInfoEncode,
SpcSpAgencyInfoDecode);
+ WINTRUST_REGISTEROID(SPC_MINIMAL_CRITERIA_OBJID, SpcMinimalCriteriaInfoEncode,
SpcMinimalCriteriaInfoDecode);
+ WINTRUST_REGISTEROID(SPC_MINIMAL_CRITERIA_STRUCT, SpcMinimalCriteriaInfoEncode,
SpcMinimalCriteriaInfoDecode);
+ WINTRUST_REGISTEROID(SPC_FINANCIAL_CRITERIA_OBJID, SpcFinancialCriteriaInfoEncode,
SpcFinancialCriteriaInfoDecode);
+ WINTRUST_REGISTEROID(SPC_FINANCIAL_CRITERIA_STRUCT, SpcFinancialCriteriaInfoEncode,
SpcFinancialCriteriaInfoDecode);
+ WINTRUST_REGISTEROID(SPC_STATEMENT_TYPE_OBJID, SpcStatementTypeEncode,
SpcStatementTypeDecode);
+ WINTRUST_REGISTEROID(SPC_STATEMENT_TYPE_STRUCT, SpcStatementTypeEncode,
SpcStatementTypeDecode);
+ WINTRUST_REGISTEROID(CAT_NAMEVALUE_OBJID, CatNameValueEncode, CatNameValueDecode);
+ WINTRUST_REGISTEROID(CAT_NAMEVALUE_STRUCT, CatNameValueEncode, CatNameValueDecode);
+ WINTRUST_REGISTEROID(CAT_MEMBERINFO_OBJID, CatMemberInfoEncode,
CatMemberInfoDecode);
+ WINTRUST_REGISTEROID(CAT_MEMBERINFO_STRUCT, CatMemberInfoEncode,
CatMemberInfoDecode);
+ WINTRUST_REGISTEROID(SPC_SP_OPUS_INFO_OBJID, SpcSpOpusInfoEncode,
SpcSpOpusInfoDecode);
+ WINTRUST_REGISTEROID(SPC_SP_OPUS_INFO_STRUCT, SpcSpOpusInfoEncode,
SpcSpOpusInfoDecode);
+
+#undef WINTRUST_REGISTEROID
+
+add_trust_providers:
+
+ /* Testing on W2K3 shows:
+ * All registry writes are tried. If one fails this part will return S_FALSE.
+ *
+ * Last error is set to the last error encountered, regardless if the first
+ * part failed or not.
+ */
+
+ /* Create the necessary action registry structures */
+ WINTRUST_InitRegStructs();
+
+ /* Register several Trust Provider actions */
+ if (!WINTRUST_RegisterGenVerifyV2())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterPublishedSoftware())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterPublishedSoftwareNoBadUi())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterGenCertVerify())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterTrustProviderTest())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterHttpsProv())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterOfficeSignVerify())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterDriverVerify())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterGenChainVerify())
+ TrustProviderRes = S_FALSE;
+
+ /* Free the registry structures */
+ WINTRUST_FreeRegStructs();
+
+ /* Testing on W2K3 shows:
+ * All registry writes are tried. If one fails this part will return S_FALSE.
+ *
+ * Last error is set to the last error encountered, regardless if the previous
+ * parts failed or not.
+ */
+
+ if (!WINTRUST_SIPPAddProvider(&Unknown1, NULL))
+ SIPAddProviderRes = S_FALSE;
+ if (!WINTRUST_SIPPAddProvider(&Unknown2, MagicNumber2))
+ SIPAddProviderRes = S_FALSE;
+ if (!WINTRUST_SIPPAddProvider(&Unknown3, MagicNumber3))
+ SIPAddProviderRes = S_FALSE;
+ if (!WINTRUST_SIPPAddProvider(&Unknown4, CafeBabe))
+ SIPAddProviderRes = S_FALSE;
+ if (!WINTRUST_SIPPAddProvider(&Unknown5, CafeBabe))
+ SIPAddProviderRes = S_FALSE;
+ if (!WINTRUST_SIPPAddProvider(&Unknown6, CafeBabe))
+ SIPAddProviderRes = S_FALSE;
+
+ /* Native does a CryptSIPRemoveProvider here for
{941C2937-1292-11D1-85BE-00C04FC295EE}.
+ * This SIP Provider is however not found on up-to-date window install and native
will
+ * set the last error to ERROR_FILE_NOT_FOUND.
+ * Wine has the last error set to ERROR_INVALID_PARAMETER. There shouldn't be an
app
+ * depending on this last error though so there is no need to imitate native to the
full extent.
+ *
+ * (The ERROR_INVALID_PARAMETER for Wine it totally valid as we (and native) do
register
+ * a trust provider without a diagnostic policy).
+ */
+
+ /* If CryptRegisterRes is not S_OK it will always overrule the return value. */
+ if (CryptRegisterRes != S_OK)
+ return CryptRegisterRes;
+ else if (SIPAddProviderRes == S_OK)
+ return TrustProviderRes;
+ else
+ return SIPAddProviderRes;
+}
+
+/***********************************************************************
+ * DllUnregisterServer (WINTRUST.@)
+ */
+HRESULT WINAPI DllUnregisterServer(void)
{
FIXME("stub\n");
return S_OK;
}
/***********************************************************************
- * DllUnregisterServer (WINTRUST.@)
- */
-HRESULT WINAPI DllUnregisterServer(void)
+ * SoftpubDllRegisterServer (WINTRUST.@)
+ *
+ * Registers softpub.dll
+ *
+ * PARAMS
+ *
+ * RETURNS
+ * Success: S_OK.
+ * Failure: S_FALSE. (See also GetLastError()).
+ *
+ * NOTES
+ * DllRegisterServer in softpub.dll will call this function.
+ * See comments in DllRegisterServer.
+ */
+HRESULT WINAPI SoftpubDllRegisterServer(void)
+{
+ HRESULT TrustProviderRes = S_OK;
+
+ TRACE("\n");
+
+ /* Create the necessary action registry structures */
+ WINTRUST_InitRegStructs();
+
+ /* Register several Trust Provider actions */
+ if (!WINTRUST_RegisterGenVerifyV2())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterPublishedSoftware())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterPublishedSoftwareNoBadUi())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterGenCertVerify())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterTrustProviderTest())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterHttpsProv())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterOfficeSignVerify())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterDriverVerify())
+ TrustProviderRes = S_FALSE;
+ if (!WINTRUST_RegisterGenChainVerify())
+ TrustProviderRes = S_FALSE;
+
+ /* Free the registry structures */
+ WINTRUST_FreeRegStructs();
+
+ return TrustProviderRes;
+}
+
+/***********************************************************************
+ * SoftpubDllUnregisterServer (WINTRUST.@)
+ */
+HRESULT WINAPI SoftpubDllUnregisterServer(void)
{
FIXME("stub\n");
return S_OK;
}
/***********************************************************************
- * SoftpubDllRegisterServer (WINTRUST.@)
- */
-HRESULT WINAPI SoftpubDllRegisterServer(void)
+ * mscat32DllRegisterServer (WINTRUST.@)
+ */
+HRESULT WINAPI mscat32DllRegisterServer(void)
{
FIXME("stub\n");
return S_OK;
}
/***********************************************************************
- * SoftpubDllUnregisterServer (WINTRUST.@)
- */
-HRESULT WINAPI SoftpubDllUnregisterServer(void)
+ * mscat32DllUnregisterServer (WINTRUST.@)
+ */
+HRESULT WINAPI mscat32DllUnregisterServer(void)
{
FIXME("stub\n");
return S_OK;
}
/***********************************************************************
- * mscat32DllRegisterServer (WINTRUST.@)
- */
-HRESULT WINAPI mscat32DllRegisterServer(void)
+ * mssip32DllRegisterServer (WINTRUST.@)
+ */
+HRESULT WINAPI mssip32DllRegisterServer(void)
{
FIXME("stub\n");
return S_OK;
}
/***********************************************************************
- * mscat32DllUnregisterServer (WINTRUST.@)
- */
-HRESULT WINAPI mscat32DllUnregisterServer(void)
+ * mssip32DllUnregisterServer (WINTRUST.@)
+ */
+HRESULT WINAPI mssip32DllUnregisterServer(void)
{
FIXME("stub\n");
return S_OK;
}
-
-/***********************************************************************
- * mssip32DllRegisterServer (WINTRUST.@)
- */
-HRESULT WINAPI mssip32DllRegisterServer(void)
-{
- FIXME("stub\n");
- return S_OK;
-}
-
-/***********************************************************************
- * mssip32DllUnregisterServer (WINTRUST.@)
- */
-HRESULT WINAPI mssip32DllUnregisterServer(void)
-{
- FIXME("stub\n");
- return S_OK;
-}
Modified: trunk/reactos/dll/win32/wintrust/wintrust.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/wintrust/wintrus…
==============================================================================
--- trunk/reactos/dll/win32/wintrust/wintrust.rbuild (original)
+++ trunk/reactos/dll/win32/wintrust/wintrust.rbuild Thu Apr 26 17:38:13 2007
@@ -1,4 +1,5 @@
<module name="wintrust" type="win32dll"
baseaddress="${BASEADDRESS_WINTRUST}" installbase="system32"
installname="wintrust.dll" allowwarnings="true">
+ <autoregister infsection="OleControlDlls"
type="DllRegisterServer" />
<importlibrary definition="wintrust.spec.def" />
<include base="wintrust">.</include>
<include base="ReactOS">include/reactos/wine</include>
@@ -10,8 +11,11 @@
<define name="WINVER">0x501</define>
<library>wine</library>
<library>crypt32</library>
+ <library>user32</library>
+ <library>advapi32</library>
<library>kernel32</library>
<library>ntdll</library>
+ <file>crypt.c</file>
<file>register.c</file>
<file>wintrust_main.c</file>
<file>version.rc</file>
Modified: trunk/reactos/dll/win32/wintrust/wintrust.spec
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/wintrust/wintrus…
==============================================================================
--- trunk/reactos/dll/win32/wintrust/wintrust.spec (original)
+++ trunk/reactos/dll/win32/wintrust/wintrust.spec Thu Apr 26 17:38:13 2007
@@ -7,7 +7,7 @@
@ stub CryptCATAdminPauseServiceForBackup
@ stub CryptCATAdminReleaseCatalogContext
@ stdcall CryptCATAdminReleaseContext(long long)
-@ stub CryptCATAdminRemoveCatalog
+@ stdcall CryptCATAdminRemoveCatalog(ptr wstr long)
@ stub CryptCATAdminResolveCatalogPath
@ stub CryptCATCDFClose
@ stub CryptCATCDFEnumAttributes
@@ -18,28 +18,28 @@
@ stub CryptCATCDFEnumMembersByCDFTagEx
@ stub CryptCATCDFOpen
@ stub CryptCATCatalogInfoFromContext
-@ stub CryptCATClose
+@ stdcall CryptCATClose(long)
@ stub CryptCATEnumerateAttr
@ stub CryptCATEnumerateCatAttr
-@ stub CryptCATEnumerateMember
+@ stdcall CryptCATEnumerateMember(long ptr)
@ stub CryptCATGetAttrInfo
@ stub CryptCATGetCatAttrInfo
@ stub CryptCATGetMemberInfo
@ stub CryptCATHandleFromStore
-@ stub CryptCATOpen
+@ stdcall CryptCATOpen(wstr long long long long)
@ stub CryptCATPersistStore
@ stub CryptCATPutAttrInfo
@ stub CryptCATPutCatAttrInfo
@ stub CryptCATPutMemberInfo
@ stub CryptCATStoreFromHandle
@ stub CryptCATVerifyMember
-@ stub CryptSIPCreateIndirectData
+@ stdcall CryptSIPCreateIndirectData(ptr ptr ptr)
@ stub CryptSIPGetInfo
@ stub CryptSIPGetRegWorkingFlags
-@ stub CryptSIPGetSignedDataMsg
-@ stub CryptSIPPutSignedDataMsg
-@ stub CryptSIPRemoveSignedDataMsg
-@ stub CryptSIPVerifyIndirectData
+@ stdcall CryptSIPGetSignedDataMsg(ptr ptr long ptr ptr)
+@ stdcall CryptSIPPutSignedDataMsg(ptr long ptr long ptr)
+@ stdcall CryptSIPRemoveSignedDataMsg(ptr long)
+@ stdcall CryptSIPVerifyIndirectData(ptr ptr)
@ stdcall -private DllRegisterServer()
@ stdcall -private DllUnregisterServer()
@ stub DriverCleanupPolicy
@@ -111,7 +111,7 @@
@ stdcall WinVerifyTrust(long ptr ptr)
@ stdcall WinVerifyTrustEx(long ptr ptr)
@ stdcall WintrustAddActionID(ptr long ptr)
-@ stub WintrustAddDefaultForUsage
+@ stdcall WintrustAddDefaultForUsage(ptr ptr)
@ stub WintrustCertificateTrust
@ stub WintrustGetDefaultForUsage
@ stdcall WintrustGetRegPolicyFlags(ptr)
Modified: trunk/reactos/dll/win32/wintrust/wintrust_main.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/wintrust/wintrus…
==============================================================================
--- trunk/reactos/dll/win32/wintrust/wintrust_main.c (original)
+++ trunk/reactos/dll/win32/wintrust/wintrust_main.c Thu Apr 26 17:38:13 2007
@@ -51,75 +51,6 @@
}
/***********************************************************************
- * CryptCATAdminAcquireContext (WINTRUST.@)
- *
- * Get a catalog administrator context handle.
- *
- * PARAMS
- * catAdmin [O] Pointer to the context handle.
- * sysSystem [I] Pointer to a GUID for the needed subsystem.
- * dwFlags [I] Reserved.
- *
- * RETURNS
- * Success: TRUE. catAdmin contains the context handle.
- * Failure: FAIL.
- *
- */
-BOOL WINAPI CryptCATAdminAcquireContext(HCATADMIN* catAdmin,
- const GUID *sysSystem, DWORD dwFlags )
-{
- FIXME("%p %s %lx\n", catAdmin, debugstr_guid(sysSystem), dwFlags);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
-}
-
-/***********************************************************************
- * CryptCATAdminCalcHashFromFileHandle (WINTRUST.@)
- */
-BOOL WINAPI CryptCATAdminCalcHashFromFileHandle(HANDLE hFile, DWORD* pcbHash,
- BYTE* pbHash, DWORD dwFlags )
-{
- FIXME("%p %p %p %lx\n", hFile, pcbHash, pbHash, dwFlags);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
-}
-
-/***********************************************************************
- * CryptCATAdminEnumCatalogFromHash (WINTRUST.@)
- */
-HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash(HCATADMIN hCatAdmin,
- BYTE* pbHash,
- DWORD cbHash,
- DWORD dwFlags,
- HCATINFO* phPrevCatInfo )
-{
- FIXME("%p %p %ld %ld %p\n", hCatAdmin, pbHash, cbHash, dwFlags,
phPrevCatInfo);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return NULL;
-}
-
-/***********************************************************************
- * CryptCATAdminReleaseContext (WINTRUST.@)
- *
- * Release a catalog administrator context handle.
- *
- * PARAMS
- * catAdmin [I] Pointer to the context handle.
- * dwFlags [I] Reserved.
- *
- * RETURNS
- * Success: TRUE.
- * Failure: FAIL.
- *
- */
-BOOL WINAPI CryptCATAdminReleaseContext(HCATADMIN hCatAdmin, DWORD dwFlags )
-{
- FIXME("%p %lx\n", hCatAdmin, dwFlags);
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
-}
-
-/***********************************************************************
* TrustIsCertificateSelfSigned (WINTRUST.@)
*/
BOOL WINAPI TrustIsCertificateSelfSigned( PCCERT_CONTEXT cert )
@@ -150,7 +81,7 @@
* Trust providers can be found at:
* HKLM\SOFTWARE\Microsoft\Cryptography\Providers\Trust\
*/
-LONG WINAPI WinVerifyTrust( HWND hwnd, GUID *ActionID, WINTRUST_DATA* ActionData )
+LONG WINAPI WinVerifyTrust( HWND hwnd, GUID *ActionID, LPVOID ActionData )
{
static const GUID gen_verify_v2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
@@ -192,7 +123,7 @@
CRYPT_PROVIDER_DATA *pProvData, DWORD idxSigner, BOOL fCounterSigner,
DWORD idxCounterSigner)
{
- FIXME("%p %ld %d %ld\n", pProvData, idxSigner, fCounterSigner,
+ FIXME("%p %d %d %d\n", pProvData, idxSigner, fCounterSigner,
idxCounterSigner);
return NULL;
}
@@ -231,6 +162,6 @@
*/
BOOL WINAPI WintrustSetRegPolicyFlags( DWORD dwPolicyFlags)
{
- FIXME("stub: %lx\n", dwPolicyFlags);
+ FIXME("stub: %x\n", dwPolicyFlags);
return TRUE;
}
Modified: trunk/reactos/dll/win32/wintrust/wintrust_ros.diff
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/wintrust/wintrus…
==============================================================================
--- trunk/reactos/dll/win32/wintrust/wintrust_ros.diff (original)
+++ trunk/reactos/dll/win32/wintrust/wintrust_ros.diff Thu Apr 26 17:38:13 2007
@@ -2,9 +2,9 @@
===================================================================
--- wintrust_main.c (revision 23867)
+++ wintrust_main.c (working copy)
-@@ -152,7 +152,26 @@
+@@ -83,7 +83,26 @@
*/
- LONG WINAPI WinVerifyTrust( HWND hwnd, GUID *ActionID, WINTRUST_DATA* ActionData )
+ LONG WINAPI WinVerifyTrust( HWND hwnd, GUID *ActionID, LPVOID ActionData )
{
+ static const GUID gen_verify_v2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
+