dlls/wintrust/tests/softpub.c

   1 /*
   2  * wintrust softpub functions tests
   3  *
   4  * Copyright 2007 Juan Lang
   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 #include <assert.h>
  21 #include <stdio.h>
  22 #include <stdarg.h>
  23 #include <windef.h>
  24 #include <winbase.h>
  25 #include <winerror.h>
  26 #include <wintrust.h>
  27 #include <softpub.h>
  28 #include <mssip.h>
  29 #include <winuser.h>
  30
  31 #include "wine/test.h"
  32
  33 /* Just in case we're being built with borked headers, redefine function
  34  * pointers to have the correct calling convention.
  35  */
  36 typedef void   *(WINAPI *SAFE_MEM_ALLOC)(DWORD);
  37 typedef void    (WINAPI *SAFE_MEM_FREE)(void *);
  38 typedef BOOL    (WINAPI *SAFE_ADD_STORE)(CRYPT_PROVIDER_DATA *,
  39  HCERTSTORE);
  40 typedef BOOL    (WINAPI *SAFE_ADD_SGNR)(CRYPT_PROVIDER_DATA *,
  41  BOOL, DWORD, struct _CRYPT_PROVIDER_SGNR *);
  42 typedef BOOL    (WINAPI *SAFE_ADD_CERT)(CRYPT_PROVIDER_DATA *,
  43  DWORD, BOOL, DWORD, PCCERT_CONTEXT);
  44 typedef BOOL    (WINAPI *SAFE_ADD_PRIVDATA)(CRYPT_PROVIDER_DATA *,
  45  CRYPT_PROVIDER_PRIVDATA *);
  46 typedef HRESULT (WINAPI *SAFE_PROVIDER_INIT_CALL)(CRYPT_PROVIDER_DATA *);
  47 typedef HRESULT (WINAPI *SAFE_PROVIDER_OBJTRUST_CALL)(CRYPT_PROVIDER_DATA *);
  48 typedef HRESULT (WINAPI *SAFE_PROVIDER_SIGTRUST_CALL)(CRYPT_PROVIDER_DATA *);
  49 typedef HRESULT (WINAPI *SAFE_PROVIDER_CERTTRUST_CALL)(CRYPT_PROVIDER_DATA *);
  50 typedef HRESULT (WINAPI *SAFE_PROVIDER_FINALPOLICY_CALL)(CRYPT_PROVIDER_DATA *);
  51 typedef HRESULT (WINAPI *SAFE_PROVIDER_TESTFINALPOLICY_CALL)(
  52  CRYPT_PROVIDER_DATA *);
  53 typedef HRESULT (WINAPI *SAFE_PROVIDER_CLEANUP_CALL)(CRYPT_PROVIDER_DATA *);
  54 typedef BOOL    (WINAPI *SAFE_PROVIDER_CERTCHKPOLICY_CALL)(
  55  CRYPT_PROVIDER_DATA *, DWORD, BOOL, DWORD);
  56
  57 typedef struct _SAFE_PROVIDER_FUNCTIONS
  58 {
  59     DWORD                              cbStruct;
  60     SAFE_MEM_ALLOC                     pfnAlloc;
  61     SAFE_MEM_FREE                      pfnFree;
  62     SAFE_ADD_STORE                     pfnAddStore2Chain;
  63     SAFE_ADD_SGNR                      pfnAddSgnr2Chain;
  64     SAFE_ADD_CERT                      pfnAddCert2Chain;
  65     SAFE_ADD_PRIVDATA                  pfnAddPrivData2Chain;
  66     SAFE_PROVIDER_INIT_CALL            pfnInitialize;
  67     SAFE_PROVIDER_OBJTRUST_CALL        pfnObjectTrust;
  68     SAFE_PROVIDER_SIGTRUST_CALL        pfnSignatureTrust;
  69     SAFE_PROVIDER_CERTTRUST_CALL       pfnCertificateTrust;
  70     SAFE_PROVIDER_FINALPOLICY_CALL     pfnFinalPolicy;
  71     SAFE_PROVIDER_CERTCHKPOLICY_CALL   pfnCertCheckPolicy;
  72     SAFE_PROVIDER_TESTFINALPOLICY_CALL pfnTestFinalPolicy;
  73     struct _CRYPT_PROVUI_FUNCS        *psUIpfns;
  74     SAFE_PROVIDER_CLEANUP_CALL         pfnCleanupPolicy;
  75 } SAFE_PROVIDER_FUNCTIONS;
  76
  77 static void testInitialize(SAFE_PROVIDER_FUNCTIONS *funcs, GUID *actionID)
  78 {
  79     HRESULT ret;
  80     CRYPT_PROVIDER_DATA data = { 0 };
  81     WINTRUST_DATA wintrust_data = { 0 };
  82
  83     if (!funcs->pfnInitialize)
  84     {
  85         skip("missing pfnInitialize\n");
  86         return;
  87     }
  88
  89     /* Crashes
  90     ret = funcs->pfnInitialize(NULL);
  91      */
  92     memset(&data, 0, sizeof(data));
  93     ret = funcs->pfnInitialize(&data);
  94     ok(ret == S_FALSE, "Expected S_FALSE, got %08x\n", ret);
  95     data.padwTrustStepErrors =
  96      funcs->pfnAlloc(TRUSTERROR_MAX_STEPS * sizeof(DWORD));
  97     /* Without wintrust data set, crashes when padwTrustStepErrors is set */
  98     data.pWintrustData = &wintrust_data;
  99     if (data.padwTrustStepErrors)
 100     {
 101         /* Apparently, cdwTrustStepErrors does not need to be set. */
 102         ret = funcs->pfnInitialize(&data);
 103         ok(ret == S_OK, "Expected S_OK, got %08x\n", ret);
 104         data.cdwTrustStepErrors = 1;
 105         ret = funcs->pfnInitialize(&data);
 106         ok(ret == S_OK, "Expected S_OK, got %08x\n", ret);
 107         memset(data.padwTrustStepErrors, 0xba,
 108          TRUSTERROR_MAX_STEPS * sizeof(DWORD));
 109         ret = funcs->pfnInitialize(&data);
 110         ok(ret == S_FALSE, "Expected S_FALSE, got %08x\n", ret);
 111         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_WVTINIT] = 0;
 112         ret = funcs->pfnInitialize(&data);
 113         ok(ret == S_OK, "Expected S_OK, got %08x\n", ret);
 114         funcs->pfnFree(data.padwTrustStepErrors);
 115     }
 116 }
 117
 118 START_TEST(softpub)
 119 {
 120     static GUID generic_verify_v2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
 121     SAFE_PROVIDER_FUNCTIONS funcs = { sizeof(SAFE_PROVIDER_FUNCTIONS), 0 };
 122     BOOL ret;
 123
 124     ret = WintrustLoadFunctionPointers(&generic_verify_v2,
 125      (CRYPT_PROVIDER_FUNCTIONS *)&funcs);
 126     if (!ret)
 127         skip("WintrustLoadFunctionPointers failed\n");
 128     else
 129     {
 130         testInitialize(&funcs, &generic_verify_v2);
 131     }
 132 }