softpub.c File Reference

#include <stdio.h>
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winerror.h>
#include <wintrust.h>
#include <softpub.h>
#include <mssip.h>
#include <winuser.h>
#include "winnls.h"
#include "wine/test.h"
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for softpub.c:

Go to the source code of this file.

Classes
struct	_SAFE_PROVIDER_FUNCTIONS
struct	Imports
struct	Imports::__IMPORT_BY_NAME
struct	_PeImage

Macros
#define	WINTRUST_GET_PROC(func)
#define	CRYPT32_GET_PROC(func)
#define	VA_START   0x400000
#define	FILE_PE_START   0x50
#define	NUM_SECTIONS   3
#define	FILE_TEXT   0x200
#define	RVA_TEXT   0x1000
#define	RVA_BSS   0x2000
#define	FILE_IDATA   0x400
#define	RVA_IDATA   0x3000
#define	FILE_TOTAL   0x600
#define	RVA_TOTAL   0x4000
#define	EXIT_PROCESS   (VA_START+RVA_IDATA+FIELD_OFFSET(struct Imports, thunks))

Typedefs
typedef void *(WINAPI *	SAFE_MEM_ALLOC) (DWORD)
typedef void(WINAPI *	SAFE_MEM_FREE) (void *)
typedef BOOL(WINAPI *	SAFE_ADD_STORE) (CRYPT_PROVIDER_DATA *, HCERTSTORE)
typedef BOOL(WINAPI *	SAFE_ADD_SGNR) (CRYPT_PROVIDER_DATA *, BOOL, DWORD, struct _CRYPT_PROVIDER_SGNR *)
typedef BOOL(WINAPI *	SAFE_ADD_CERT) (CRYPT_PROVIDER_DATA *, DWORD, BOOL, DWORD, PCCERT_CONTEXT)
typedef BOOL(WINAPI *	SAFE_ADD_PRIVDATA) (CRYPT_PROVIDER_DATA *, CRYPT_PROVIDER_PRIVDATA *)
typedef HRESULT(WINAPI *	SAFE_PROVIDER_INIT_CALL) (CRYPT_PROVIDER_DATA *)
typedef HRESULT(WINAPI *	SAFE_PROVIDER_OBJTRUST_CALL) (CRYPT_PROVIDER_DATA *)
typedef HRESULT(WINAPI *	SAFE_PROVIDER_SIGTRUST_CALL) (CRYPT_PROVIDER_DATA *)
typedef HRESULT(WINAPI *	SAFE_PROVIDER_CERTTRUST_CALL) (CRYPT_PROVIDER_DATA *)
typedef HRESULT(WINAPI *	SAFE_PROVIDER_FINALPOLICY_CALL) (CRYPT_PROVIDER_DATA *)
typedef HRESULT(WINAPI *	SAFE_PROVIDER_TESTFINALPOLICY_CALL) (CRYPT_PROVIDER_DATA *)
typedef HRESULT(WINAPI *	SAFE_PROVIDER_CLEANUP_CALL) (CRYPT_PROVIDER_DATA *)
typedef BOOL(WINAPI *	SAFE_PROVIDER_CERTCHKPOLICY_CALL) (CRYPT_PROVIDER_DATA *, DWORD, BOOL, DWORD)
typedef struct _SAFE_PROVIDER_FUNCTIONS	SAFE_PROVIDER_FUNCTIONS

Functions
static	BOOL (WINAPI *pWTHelperGetKnownUsages)(DWORD action
static DWORD SIP_INDIRECT_DATA *static	VOID (WINAPI *CertFreeCertificateChain_p)(PCCERT_CHAIN_CONTEXT)
static void	InitFunctionPtrs (void)
static void	test_utils (SAFE_PROVIDER_FUNCTIONS *funcs)
static void	testInitialize (SAFE_PROVIDER_FUNCTIONS *funcs, GUID *actionID)
static void	getNotepadPath (WCHAR *notepadPathW, DWORD size)
static HANDLE	create_temp_file (WCHAR *temp_file)
static void	testObjTrust (SAFE_PROVIDER_FUNCTIONS *funcs, GUID *actionID)
static void	testCertTrust (SAFE_PROVIDER_FUNCTIONS *funcs, GUID *actionID)
static void	test_provider_funcs (void)
static void	test_sip_create_indirect_data (void)
static void	test_wintrust (void)
static void	call_winverify (WCHAR *pathW, LONG *status, BOOL hash_only)
static void	test_wintrust_digest (void)
static void	test_get_known_usages (void)
static void	test_multiple_signatures (void)
static void	test_pe_image_hash (void)
	START_TEST (softpub)

Variables
static PCCRYPT_OID_INFO **	usages
static const BYTE	v1CertWithPubKey []
static const BYTE	selfSignedCert []
static struct _PeImage	bin
static const BYTE	SelfSignedFile32 []
static const BYTE	SelfSignedFile64 []
static const BYTE	self_signed_3certs []
static DWORD BYTE	DWORD

Macro Definition Documentation

CRYPT32_GET_PROC

#define CRYPT32_GET_PROC

(

func

)

Value:

    func ## _p = (void*)GetProcAddress(hCrypt32, #func); \
    if(!func ## _p) { \
      trace("GetProcAddress(%s) failed\n", #func); \
    }

EXIT_PROCESS

#define EXIT_PROCESS   (VA_START+RVA_IDATA+FIELD_OFFSET(struct Imports, thunks))

Definition at line 670 of file softpub.c.

FILE_IDATA

#define FILE_IDATA   0x400

Definition at line 655 of file softpub.c.

FILE_PE_START

#define FILE_PE_START   0x50

Definition at line 650 of file softpub.c.

FILE_TEXT

#define FILE_TEXT   0x200

Definition at line 652 of file softpub.c.

FILE_TOTAL

#define FILE_TOTAL   0x600

Definition at line 657 of file softpub.c.

NUM_SECTIONS

#define NUM_SECTIONS   3

Definition at line 651 of file softpub.c.

RVA_BSS

#define RVA_BSS   0x2000

Definition at line 654 of file softpub.c.

RVA_IDATA

#define RVA_IDATA   0x3000

Definition at line 656 of file softpub.c.

RVA_TEXT

#define RVA_TEXT   0x1000

Definition at line 653 of file softpub.c.

RVA_TOTAL

#define RVA_TOTAL   0x4000

Definition at line 658 of file softpub.c.

VA_START

#define VA_START   0x400000

Definition at line 649 of file softpub.c.

WINTRUST_GET_PROC

#define WINTRUST_GET_PROC

(

func

)

Value:

    p ## func = (void*)GetProcAddress(hWintrust, #func); \
    if(!p ## func) { \
      trace("GetProcAddress(%s) failed\n", #func); \
    }

Typedef Documentation

SAFE_ADD_CERT

typedef BOOL(WINAPI * SAFE_ADD_CERT) (CRYPT_PROVIDER_DATA *, DWORD, BOOL, DWORD, PCCERT_CONTEXT)

Definition at line 46 of file softpub.c.

SAFE_ADD_PRIVDATA

typedef BOOL(WINAPI * SAFE_ADD_PRIVDATA) (CRYPT_PROVIDER_DATA *, CRYPT_PROVIDER_PRIVDATA *)

Definition at line 48 of file softpub.c.

SAFE_ADD_SGNR

typedef BOOL(WINAPI * SAFE_ADD_SGNR) (CRYPT_PROVIDER_DATA *, BOOL, DWORD, struct _CRYPT_PROVIDER_SGNR *)

Definition at line 44 of file softpub.c.

SAFE_ADD_STORE

typedef BOOL(WINAPI * SAFE_ADD_STORE) (CRYPT_PROVIDER_DATA *, HCERTSTORE)

Definition at line 42 of file softpub.c.

SAFE_MEM_ALLOC

typedef void *(WINAPI * SAFE_MEM_ALLOC) (DWORD)

Definition at line 40 of file softpub.c.

SAFE_MEM_FREE

typedef void(WINAPI * SAFE_MEM_FREE) (void *)

Definition at line 41 of file softpub.c.

SAFE_PROVIDER_CERTCHKPOLICY_CALL

typedef BOOL(WINAPI * SAFE_PROVIDER_CERTCHKPOLICY_CALL) (CRYPT_PROVIDER_DATA *, DWORD, BOOL, DWORD)

Definition at line 58 of file softpub.c.

SAFE_PROVIDER_CERTTRUST_CALL

typedef HRESULT(WINAPI * SAFE_PROVIDER_CERTTRUST_CALL) (CRYPT_PROVIDER_DATA *)

Definition at line 53 of file softpub.c.

SAFE_PROVIDER_CLEANUP_CALL

typedef HRESULT(WINAPI * SAFE_PROVIDER_CLEANUP_CALL) (CRYPT_PROVIDER_DATA *)

Definition at line 57 of file softpub.c.

SAFE_PROVIDER_FINALPOLICY_CALL

typedef HRESULT(WINAPI * SAFE_PROVIDER_FINALPOLICY_CALL) (CRYPT_PROVIDER_DATA *)

Definition at line 54 of file softpub.c.

SAFE_PROVIDER_FUNCTIONS

typedef struct _SAFE_PROVIDER_FUNCTIONS SAFE_PROVIDER_FUNCTIONS

SAFE_PROVIDER_INIT_CALL

typedef HRESULT(WINAPI * SAFE_PROVIDER_INIT_CALL) (CRYPT_PROVIDER_DATA *)

Definition at line 50 of file softpub.c.

SAFE_PROVIDER_OBJTRUST_CALL

typedef HRESULT(WINAPI * SAFE_PROVIDER_OBJTRUST_CALL) (CRYPT_PROVIDER_DATA *)

Definition at line 51 of file softpub.c.

SAFE_PROVIDER_SIGTRUST_CALL

typedef HRESULT(WINAPI * SAFE_PROVIDER_SIGTRUST_CALL) (CRYPT_PROVIDER_DATA *)

Definition at line 52 of file softpub.c.

SAFE_PROVIDER_TESTFINALPOLICY_CALL

typedef HRESULT(WINAPI * SAFE_PROVIDER_TESTFINALPOLICY_CALL) (CRYPT_PROVIDER_DATA *)

Definition at line 55 of file softpub.c.

Function Documentation

BOOL()

static BOOL ( WINAPI *  pWTHelperGetKnownUsages )

static

call_winverify()

static void call_winverify ( WCHAR *  pathW, LONG *  status, BOOL  hash_only  )

static

Definition at line 1596 of file softpub.c.

{
    static GUID WVTPolicyGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
    WINTRUST_FILE_INFO file_info = { sizeof(file_info), 0 };
    WINTRUST_DATA data = { sizeof(data), 0 };
    LONG ret;
 
    file_info.pcwszFilePath     = pathW;
 
    data.dwUIChoice             = WTD_UI_NONE;
    data.fdwRevocationChecks    = WTD_REVOKE_NONE;
    data.dwUnionChoice          = WTD_CHOICE_FILE;
    data.pFile                  = &file_info;
    data.dwStateAction          = WTD_STATEACTION_VERIFY;
    data.dwProvFlags            = hash_only ? WTD_HASH_ONLY_FLAG : 0;
    *status = WinVerifyTrust(NULL, &WVTPolicyGUID, &data);
 
    data.dwStateAction = WTD_STATEACTION_CLOSE;
    ret = WinVerifyTrust(NULL, &WVTPolicyGUID, &data);
    ok(ret == S_OK, "WinVerifyTrust failed: %08lx\n", ret);
}

Referenced by test_wintrust_digest().

create_temp_file()

static HANDLE create_temp_file ( WCHAR *  temp_file )

static

Definition at line 286 of file softpub.c.

{
    HANDLE file = INVALID_HANDLE_VALUE;
    WCHAR temp_path[MAX_PATH];
 
    if (GetTempPathW(ARRAY_SIZE(temp_path), temp_path))
    {
        static const WCHAR img[] = { 'i','m','g',0 };
 
        if (GetTempFileNameW(temp_path, img, 0, temp_file))
            file = CreateFileW(temp_file, GENERIC_READ | GENERIC_WRITE, 0, NULL,
             CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    }
    return file;
}

Referenced by test_bind_image_ex(), test_get_digest_stream(), test_image_load(), test_multiple_signatures(), test_pe_image_hash(), test_sip_create_indirect_data(), test_wintrust(), test_wintrust_digest(), and testObjTrust().

getNotepadPath()

static void getNotepadPath ( WCHAR *  notepadPathW, DWORD  size  )

static

Definition at line 272 of file softpub.c.

{
    static const CHAR notepad[] = "\\notepad.exe";
    CHAR notepadPath[MAX_PATH];
 
    /* Workaround missing W-functions for win9x */
    GetWindowsDirectoryA(notepadPath, MAX_PATH);
    lstrcatA(notepadPath, notepad);
    MultiByteToWideChar(CP_ACP, 0, notepadPath, -1, notepadPathW, size);
}

Referenced by test_wintrust(), and testObjTrust().

InitFunctionPtrs()

static void InitFunctionPtrs ( void  )

static

Definition at line 85 of file softpub.c.

{
    HMODULE hWintrust = GetModuleHandleA("wintrust.dll");
    HMODULE hCrypt32 = GetModuleHandleA("crypt32.dll");
 
#define WINTRUST_GET_PROC(func) \
    p ## func = (void*)GetProcAddress(hWintrust, #func); \
    if(!p ## func) { \
      trace("GetProcAddress(%s) failed\n", #func); \
    }
 
    WINTRUST_GET_PROC(WTHelperGetKnownUsages)
 
#undef WINTRUST_GET_PROC
 
#define CRYPT32_GET_PROC(func) \
    func ## _p = (void*)GetProcAddress(hCrypt32, #func); \
    if(!func ## _p) { \
      trace("GetProcAddress(%s) failed\n", #func); \
    }
 
    CRYPT32_GET_PROC(CryptSIPCreateIndirectData)
    CRYPT32_GET_PROC(CertFreeCertificateChain)
 
#undef CRYPT32_GET_PROC
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

softpub

)

Definition at line 1928 of file softpub.c.

{
    InitFunctionPtrs();
    test_provider_funcs();
    test_sip_create_indirect_data();
    test_wintrust();
    test_wintrust_digest();
    test_get_known_usages();
    test_multiple_signatures();
    test_pe_image_hash();
}

test_get_known_usages()

static void test_get_known_usages ( void  )

static

Definition at line 1721 of file softpub.c.

{
    BOOL ret;
    PCCRYPT_OID_INFO *usages;
 
    if (!pWTHelperGetKnownUsages)
    {
        skip("missing WTHelperGetKnownUsages\n");
        return;
    }
    SetLastError(0xdeadbeef);
    ret = pWTHelperGetKnownUsages(0, NULL);
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
     "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
    SetLastError(0xdeadbeef);
    ret = pWTHelperGetKnownUsages(1, NULL);
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
     "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
    SetLastError(0xdeadbeef);
    ret = pWTHelperGetKnownUsages(0, &usages);
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
     "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
    /* A value of 1 for the first parameter seems to imply the value is
     * allocated
     */
    SetLastError(0xdeadbeef);
    usages = NULL;
    ret = pWTHelperGetKnownUsages(1, &usages);
    ok(ret, "WTHelperGetKnownUsages failed: %ld\n", GetLastError());
    ok(usages != NULL, "expected a pointer\n");
    if (ret && usages)
    {
        PCCRYPT_OID_INFO *ptr;
 
        /* The returned usages are an array of PCCRYPT_OID_INFOs, terminated with a
         * NULL pointer.
         */
        for (ptr = usages; *ptr; ptr++)
        {
            ok((*ptr)->cbSize == sizeof(CRYPT_OID_INFO) ||
             (*ptr)->cbSize == (sizeof(CRYPT_OID_INFO) + 2 * sizeof(LPCWSTR)), /* Vista */
             "unexpected size %ld\n", (*ptr)->cbSize);
            /* Each returned usage is in the CRYPT_ENHKEY_USAGE_OID_GROUP_ID group */
            ok((*ptr)->dwGroupId == CRYPT_ENHKEY_USAGE_OID_GROUP_ID,
             "expected group CRYPT_ENHKEY_USAGE_OID_GROUP_ID, got %ld\n",
             (*ptr)->dwGroupId);
        }
    }
    /* A value of 2 for the second parameter seems to imply the value is freed
     */
    SetLastError(0xdeadbeef);
    ret = pWTHelperGetKnownUsages(2, &usages);
    ok(ret, "WTHelperGetKnownUsages failed: %ld\n", GetLastError());
    ok(usages == NULL, "expected pointer to be cleared\n");
    SetLastError(0xdeadbeef);
    usages = NULL;
    ret = pWTHelperGetKnownUsages(2, &usages);
    ok(ret, "WTHelperGetKnownUsages failed: %ld\n", GetLastError());
    SetLastError(0xdeadbeef);
    ret = pWTHelperGetKnownUsages(2, NULL);
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
     "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
}

Referenced by START_TEST().

test_multiple_signatures()

static void test_multiple_signatures ( void  )

static

Definition at line 1785 of file softpub.c.

{
    static const BYTE serials[][16] =
    {
        { 0xfa, 0x4b, 0x40, 0x69, 0x40, 0x4b, 0xc0, 0x44, 0xa2, 0x31, 0x3a, 0xa7, 0xaa, 0x97, 0x73, 0xd1, },
        { 0xcc, 0x03, 0x6b, 0x72, 0x4a, 0x93, 0x42, 0x40, 0x8f, 0x93, 0x41, 0x68, 0xa9, 0xec, 0x01, 0x8d, },
        { 0xa1, 0x58, 0x5b, 0x68, 0x85, 0x6a, 0x91, 0x4d, 0xa7, 0xe3, 0xa4, 0x15, 0x08, 0x3e, 0xfb, 0xae, },
    };
    static GUID WVTPolicyGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
    WINTRUST_SIGNATURE_SETTINGS settings = { sizeof(settings) };
    WINTRUST_FILE_INFO file_info = { sizeof(file_info) };
    WINTRUST_DATA data = { sizeof(data) };
    CRYPT_PROVIDER_DATA *prov;
    WCHAR pathW[MAX_PATH];
    CERT_INFO *cert_info;
    unsigned int i;
    BYTE buf[4096];
    DWORD written;
    LONG status;
    HANDLE file;
    DWORD size;
    BOOL bret;
 
    file = create_temp_file(pathW);
    ok(file != INVALID_HANDLE_VALUE, "Failed to create temporary file.\n");
    bret = WriteFile(file, self_signed_3certs, sizeof(self_signed_3certs), &written, NULL);
    ok(bret, "Failed, err %lu.\n", GetLastError());
    CloseHandle(file);
 
    file_info.pcwszFilePath = pathW;
    data.dwUIChoice = WTD_UI_NONE;
    data.fdwRevocationChecks = WTD_REVOKE_NONE;
    data.dwUnionChoice = WTD_CHOICE_FILE;
    data.pFile = &file_info;
    data.dwStateAction = WTD_STATEACTION_VERIFY;
    data.dwProvFlags = 0;
    data.pSignatureSettings = &settings;
 
    settings.cSecondarySigs = 0xcccccccc;
    settings.dwVerifiedSigIndex = 0xcccccccc;
    status = WinVerifyTrust(NULL, &WVTPolicyGUID, &data);
    todo_wine ok(status == CERT_E_UNTRUSTEDROOT || status == CERT_E_CHAINING, "Failed, ret %#lx\n", status);
    ok(settings.cSecondarySigs == 0xcccccccc, "Got %lu.\n", settings.cSecondarySigs);
    todo_wine ok(settings.dwVerifiedSigIndex == 2, "Got %lu.\n", settings.dwVerifiedSigIndex);
 
    prov = (CRYPT_PROVIDER_DATA *)data.hWVTStateData;
    ok(prov->cbStruct == sizeof(*prov), "Got size %lu.\n", prov->cbStruct);
    ok(prov->csSigners == 1, "Got %lu.\n", prov->csSigners);
    ok(prov->pSigSettings == &settings, "Got %p, expected %p.\n", prov->pSigSettings, &settings);
    ok(!!prov->pSigState, "Got %p, expected %p.\n", prov->pSigSettings, &settings);
    if (prov->cbStruct == sizeof(*prov) && prov->pSigState)
    {
        ok(prov->pSigState->cbStruct == sizeof(*prov->pSigState)
                || broken(prov->pSigState->cbStruct == offsetof(CRYPT_PROVIDER_SIGSTATE, iAttemptCount)) /* Win7 */,
                "Got %lu.\n", prov->pSigState->cbStruct);
        ok(prov->pSigState->fSupportMultiSig, "Got %d.\n", prov->pSigState->fSupportMultiSig);
        ok(prov->pSigState->dwCryptoPolicySupport == (WSS_SIGTRUST_SUPPORT | WSS_OBJTRUST_SUPPORT
                | WSS_CERTTRUST_SUPPORT), "Got %#lx.\n", prov->pSigState->dwCryptoPolicySupport);
        ok(prov->pSigState->cSecondarySigs == 2, "Got %lu.\n", prov->pSigState->cSecondarySigs);
 
        size = sizeof(buf);
        bret = CryptMsgGetParam(prov->pSigState->hPrimarySig, CMSG_SIGNER_CERT_INFO_PARAM, 0, buf, &size);
        ok(bret, "Failed, err %#lx.\n", GetLastError());
        cert_info = (CERT_INFO *)buf;
        ok(cert_info->SerialNumber.cbData == sizeof(serials[0]), "Got %lu.\n", cert_info->SerialNumber.cbData);
        ok(!memcmp(cert_info->SerialNumber.pbData, serials[0], sizeof(serials[0])), "Data does not match.\n");
        for (i = 0; i < prov->pSigState->cSecondarySigs; ++i)
        {
            bret = CryptMsgGetParam(prov->pSigState->rhSecondarySigs[i], CMSG_SIGNER_CERT_INFO_PARAM, 0, buf, &size);
            ok(bret, "Failed, err %#lx.\n", GetLastError());
            ok(cert_info->SerialNumber.cbData == sizeof(serials[0]), "Got %lu.\n", cert_info->SerialNumber.cbData);
            ok(!memcmp(cert_info->SerialNumber.pbData, serials[i + 1], sizeof(serials[0])), "Data does not match.\n");
        }
    }
 
    data.dwStateAction = WTD_STATEACTION_CLOSE;
    status = WinVerifyTrust(NULL, &WVTPolicyGUID, &data);
    ok(status == S_OK, "Failed, ret %#lx\n", status);
 
    data.dwStateAction = WTD_STATEACTION_VERIFY;
    settings.dwFlags = WSS_GET_SECONDARY_SIG_COUNT;
    settings.cSecondarySigs = 0xcccccccc;
    settings.dwVerifiedSigIndex = 0xcccccccc;
    status = WinVerifyTrust(NULL, &WVTPolicyGUID, &data);
    todo_wine ok(status == CERT_E_UNTRUSTEDROOT || status == CERT_E_CHAINING, "Failed, ret %#lx\n", status);
    ok(settings.cSecondarySigs == 2, "Got %lu.\n", settings.cSecondarySigs);
    todo_wine ok(settings.dwVerifiedSigIndex == 2, "Got %lu.\n", settings.dwVerifiedSigIndex);
 
    data.dwStateAction = WTD_STATEACTION_CLOSE;
    status = WinVerifyTrust(NULL, &WVTPolicyGUID, &data);
    ok(status == S_OK, "Failed, ret %#lx\n", status);
 
    data.dwStateAction = WTD_STATEACTION_VERIFY;
    settings.dwFlags = WSS_VERIFY_SPECIFIC | WSS_GET_SECONDARY_SIG_COUNT;
    settings.cSecondarySigs = 0xcccccccc;
    settings.dwVerifiedSigIndex = 0xcccccccc;
    settings.dwIndex = 1;
    status = WinVerifyTrust(NULL, &WVTPolicyGUID, &data);
    todo_wine ok(status == CERT_E_UNTRUSTEDROOT || status == CERT_E_CHAINING, "Failed, ret %#lx\n", status);
    ok(settings.cSecondarySigs == 2, "Got %lu.\n", settings.cSecondarySigs);
    todo_wine ok(settings.dwVerifiedSigIndex == 1, "Got %lu.\n", settings.dwVerifiedSigIndex);
    settings.dwIndex = 0;
 
    data.dwStateAction = WTD_STATEACTION_CLOSE;
    status = WinVerifyTrust(NULL, &WVTPolicyGUID, &data);
    ok(status == S_OK, "Failed, ret %#lx\n", status);
 
    DeleteFileW(pathW);
}

Referenced by START_TEST().

test_pe_image_hash()

static void test_pe_image_hash ( void  )

static

Definition at line 1897 of file softpub.c.

{
    static const char expected[] =
        {0x8a,0xd5,0x45,0x53,0x3d,0x67,0xdf,0x2f,0x78,0xe0,0x55,0x0a,0xe0,0xd9,0x7a,0x28,0x3e,0xbf,0x45,0x2b};
    WCHAR path[MAX_PATH];
    HANDLE file;
    BYTE sha1[20];
    DWORD size, count;
    HMODULE wintrust = GetModuleHandleA("wintrust.dll");
    BOOL ret;
 
    pCryptCATAdminCalcHashFromFileHandle = (void *)GetProcAddress(wintrust, "CryptCATAdminCalcHashFromFileHandle");
    if (!pCryptCATAdminCalcHashFromFileHandle)
    {
        win_skip("hash function missing\n");
        return;
    }
 
    file = create_temp_file(path);
    WriteFile(file, &bin, sizeof(bin), &count, NULL);
 
    size = sizeof(sha1);
    memset(sha1, 0, sizeof(sha1));
    ret = pCryptCATAdminCalcHashFromFileHandle(file, &size, sha1, 0);
    ok(ret, "got %lu\n", GetLastError());
    ok(!memcmp(sha1, expected, sizeof(sha1)), "wrong hash\n");
 
    CloseHandle(file);
    DeleteFileW(path);
}

Referenced by START_TEST().

test_provider_funcs()

static void test_provider_funcs ( void  )

static

Definition at line 629 of file softpub.c.

{
    static GUID generic_verify_v2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
    SAFE_PROVIDER_FUNCTIONS funcs = { sizeof(SAFE_PROVIDER_FUNCTIONS), 0 };
    BOOL ret;
 
    ret = WintrustLoadFunctionPointers(&generic_verify_v2,
     (CRYPT_PROVIDER_FUNCTIONS *)&funcs);
    if (!ret)
        skip("WintrustLoadFunctionPointers failed\n");
    else
    {
        test_utils(&funcs);
        testInitialize(&funcs, &generic_verify_v2);
        testObjTrust(&funcs, &generic_verify_v2);
        testCertTrust(&funcs, &generic_verify_v2);
    }
}

Referenced by START_TEST().

test_sip_create_indirect_data()

static void test_sip_create_indirect_data ( void  )

static

Definition at line 740 of file softpub.c.

{
    static GUID unknown = { 0xC689AAB8, 0x8E78, 0x11D0, { 0x8C,0x47,
     0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
    static char oid_sha1[] = szOID_OIWSEC_sha1;
    BOOL ret;
    SIP_SUBJECTINFO subjinfo = { 0 };
    WCHAR temp_file[MAX_PATH];
    HANDLE file;
    DWORD count;
 
    if (!CryptSIPCreateIndirectData_p)
    {
        skip("Missing CryptSIPCreateIndirectData\n");
        return;
    }
    SetLastError(0xdeadbeef);
    ret = CryptSIPCreateIndirectData_p(NULL, NULL, NULL);
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
    SetLastError(0xdeadbeef);
    ret = CryptSIPCreateIndirectData_p(&subjinfo, NULL, NULL);
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
    subjinfo.cbSize = sizeof(subjinfo);
    SetLastError(0xdeadbeef);
    ret = CryptSIPCreateIndirectData_p(&subjinfo, NULL, NULL);
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
    file = create_temp_file(temp_file);
    if (file == INVALID_HANDLE_VALUE)
    {
        skip("couldn't create temp file\n");
        return;
    }
    WriteFile(file, &bin, sizeof(bin), &count, NULL);
    FlushFileBuffers(file);
 
    subjinfo.hFile = file;
    SetLastError(0xdeadbeef);
    ret = CryptSIPCreateIndirectData_p(&subjinfo, NULL, NULL);
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
    subjinfo.pgSubjectType = &unknown;
    SetLastError(0xdeadbeef);
    ret = CryptSIPCreateIndirectData_p(&subjinfo, NULL, NULL);
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
    subjinfo.DigestAlgorithm.pszObjId = oid_sha1;
    count = 0xdeadbeef;
    ret = CryptSIPCreateIndirectData_p(&subjinfo, &count, NULL);
    todo_wine
    ok(ret, "CryptSIPCreateIndirectData failed: %ld\n", GetLastError());
    ok(count, "expected a positive count\n");
    if (ret)
    {
        SIP_INDIRECT_DATA *indirect = HeapAlloc(GetProcessHeap(), 0, count);
 
        count = 256;
        ret = CryptSIPCreateIndirectData_p(&subjinfo, &count, indirect);
        ok(ret, "CryptSIPCreateIndirectData failed: %ld\n", GetLastError());
        /* If the count is larger than needed, it's unmodified */
        ok(count == 256, "unexpected count %ld\n", count);
        ok(!strcmp(indirect->Data.pszObjId, SPC_PE_IMAGE_DATA_OBJID),
           "unexpected data oid %s\n",
           indirect->Data.pszObjId);
        ok(!strcmp(indirect->DigestAlgorithm.pszObjId, oid_sha1),
           "unexpected digest algorithm oid %s\n",
           indirect->DigestAlgorithm.pszObjId);
        ok(indirect->Digest.cbData == 20, "unexpected hash size %ld\n",
           indirect->Digest.cbData);
        if (indirect->Digest.cbData == 20)
        {
            const BYTE hash[20] = {
                0x8a,0xd5,0x45,0x53,0x3d,0x67,0xdf,0x2f,0x78,0xe0,
                0x55,0x0a,0xe0,0xd9,0x7a,0x28,0x3e,0xbf,0x45,0x2b };
 
            ok(!memcmp(indirect->Digest.pbData, hash, 20),
               "unexpected value\n");
        }
 
        HeapFree(GetProcessHeap(), 0, indirect);
    }
    CloseHandle(file);
    DeleteFileW(temp_file);
}

Referenced by START_TEST().

test_utils()

static void test_utils ( SAFE_PROVIDER_FUNCTIONS *  funcs )

static

Definition at line 125 of file softpub.c.

{
    CRYPT_PROVIDER_DATA data = { 0 };
    HCERTSTORE store;
    CRYPT_PROVIDER_SGNR sgnr = { 0 };
    BOOL ret;
 
    /* Crash
    ret = funcs->pfnAddStore2Chain(NULL, NULL);
    ret = funcs->pfnAddStore2Chain(&data, NULL);
     */
    store = CertOpenStore(CERT_STORE_PROV_MEMORY, X509_ASN_ENCODING, 0,
     CERT_STORE_CREATE_NEW_FLAG, NULL);
    if (store)
    {
        ret = funcs->pfnAddStore2Chain(&data, store);
        ok(ret, "pfnAddStore2Chain failed: %08lx\n", GetLastError());
        ok(data.chStores == 1, "Expected 1 store, got %ld\n", data.chStores);
        ok(data.pahStores != NULL, "Expected pahStores to be allocated\n");
        if (data.pahStores)
        {
            ok(data.pahStores[0] == store, "Unexpected store\n");
            CertCloseStore(data.pahStores[0], 0);
            funcs->pfnFree(data.pahStores);
            data.pahStores = NULL;
            data.chStores = 0;
            CertCloseStore(store, 0);
            store = NULL;
        }
    }
    else
        skip("CertOpenStore failed: %08lx\n", GetLastError());
 
    /* Crash
    ret = funcs->pfnAddSgnr2Chain(NULL, FALSE, 0, NULL);
    ret = funcs->pfnAddSgnr2Chain(&data, FALSE, 0, NULL);
     */
    ret = funcs->pfnAddSgnr2Chain(&data, FALSE, 0, &sgnr);
    ok(ret, "pfnAddSgnr2Chain failed: %08lx\n", GetLastError());
    ok(data.csSigners == 1, "Expected 1 signer, got %ld\n", data.csSigners);
    ok(data.pasSigners != NULL, "Expected pasSigners to be allocated\n");
    if (data.pasSigners)
    {
        PCCERT_CONTEXT cert;
 
        ok(!memcmp(&data.pasSigners[0], &sgnr, sizeof(sgnr)),
         "Unexpected data in signer\n");
        /* Adds into the location specified by the index */
        sgnr.cbStruct = sizeof(CRYPT_PROVIDER_SGNR);
        sgnr.sftVerifyAsOf.dwLowDateTime = 0xdeadbeef;
        ret = funcs->pfnAddSgnr2Chain(&data, FALSE, 1, &sgnr);
        ok(ret, "pfnAddSgnr2Chain failed: %08lx\n", GetLastError());
        ok(data.csSigners == 2, "Expected 2 signers, got %ld\n", data.csSigners);
        ok(!memcmp(&data.pasSigners[1], &sgnr, sizeof(sgnr)),
         "Unexpected data in signer\n");
        /* This also adds, but the index is ignored */
        sgnr.cbStruct = sizeof(DWORD);
        ret = funcs->pfnAddSgnr2Chain(&data, FALSE, 0, &sgnr);
        ok(ret, "pfnAddSgnr2Chain failed: %08lx\n", GetLastError());
        ok(data.csSigners == 3, "Expected 3 signers, got %ld\n", data.csSigners);
        sgnr.sftVerifyAsOf.dwLowDateTime = 0;
        todo_wine
        ok(!memcmp(&data.pasSigners[2], &sgnr, sizeof(sgnr)),
           "Unexpected data in signer\n");
        /* But too large a thing isn't added */
        sgnr.cbStruct = sizeof(sgnr) + sizeof(DWORD);
        SetLastError(0xdeadbeef);
        ret = funcs->pfnAddSgnr2Chain(&data, FALSE, 0, &sgnr);
        ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
         "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
 
        /* Crash
        ret = funcs->pfnAddCert2Chain(NULL, 0, FALSE, 0, NULL);
        ret = funcs->pfnAddCert2Chain(&data, 0, FALSE, 0, NULL);
         */
        cert = CertCreateCertificateContext(X509_ASN_ENCODING, v1CertWithPubKey,
         sizeof(v1CertWithPubKey));
        if (cert)
        {
            /* Notes on behavior that are hard to test:
             * 1. If pasSigners is invalid, pfnAddCert2Chain crashes
             * 2. An invalid signer index isn't checked.
             */
            ret = funcs->pfnAddCert2Chain(&data, 0, FALSE, 0, cert);
            ok(ret, "pfnAddCert2Chain failed: %08lx\n", GetLastError());
            ok(data.pasSigners[0].csCertChain == 1, "Expected 1 cert, got %ld\n",
             data.pasSigners[0].csCertChain);
            ok(data.pasSigners[0].pasCertChain != NULL,
             "Expected pasCertChain to be allocated\n");
            if (data.pasSigners[0].pasCertChain)
            {
                ok(data.pasSigners[0].pasCertChain[0].pCert == cert,
                 "Unexpected cert\n");
                CertFreeCertificateContext(
                 data.pasSigners[0].pasCertChain[0].pCert);
            }
            CertFreeCertificateContext(cert);
        }
        else
            skip("CertCreateCertificateContext failed: %08lx\n", GetLastError());
        funcs->pfnFree(data.pasSigners);
    }
}

Referenced by test_provider_funcs().

test_wintrust()

static void test_wintrust ( void  )

static

Definition at line 827 of file softpub.c.

{
    static GUID generic_action_v2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
    WINTRUST_DATA wtd;
    WINTRUST_FILE_INFO file;
    LONG r;
    HRESULT hr;
    WCHAR pathW[MAX_PATH];
 
    memset(&wtd, 0, sizeof(wtd));
    wtd.cbStruct = sizeof(wtd);
    wtd.dwUIChoice = WTD_UI_NONE;
    wtd.fdwRevocationChecks = WTD_REVOKE_WHOLECHAIN;
    wtd.dwUnionChoice = WTD_CHOICE_FILE;
    wtd.pFile = &file;
    wtd.dwStateAction = WTD_STATEACTION_VERIFY;
    memset(&file, 0, sizeof(file));
    file.cbStruct = sizeof(file);
    file.pcwszFilePath = pathW;
    /* Test with an empty file */
    file.hFile = create_temp_file(pathW);
    SetLastError(0xdeadbeef);
    r = WinVerifyTrust(INVALID_HANDLE_VALUE, &generic_action_v2, &wtd);
    ok(r == GetLastError(), "expected %08lx, got %08lx\n", GetLastError(), r);
    ok(r == TRUST_E_SUBJECT_FORM_UNKNOWN,
     "expected TRUST_E_SUBJECT_FORM_UNKNOWN, got %08lx\n", r);
    CloseHandle(file.hFile);
    DeleteFileW(pathW);
    file.hFile = NULL;
    /* Test with a known file path, which we expect not have a signature */
    getNotepadPath(pathW, MAX_PATH);
    SetLastError(0xdeadbeef);
    r = WinVerifyTrust(INVALID_HANDLE_VALUE, &generic_action_v2, &wtd);
    ok(r == GetLastError(), "expected %08lx, got %08lx\n", GetLastError(), r);
    ok(r == TRUST_E_NOSIGNATURE || r == CRYPT_E_FILE_ERROR,
     "expected TRUST_E_NOSIGNATURE or CRYPT_E_FILE_ERROR, got %08lx\n", r);
    wtd.dwStateAction = WTD_STATEACTION_CLOSE;
    SetLastError(0xdeadbeef);
    r = WinVerifyTrust(INVALID_HANDLE_VALUE, &generic_action_v2, &wtd);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %08lx\n", GetLastError());
    ok(r == S_OK, "WinVerifyTrust failed: %08lx\n", r);
    wtd.dwStateAction = WTD_STATEACTION_VERIFY;
    SetLastError(0xdeadbeef);
    hr = WinVerifyTrustEx(INVALID_HANDLE_VALUE, &generic_action_v2, &wtd);
    ok(hr == GetLastError(), "expected %08lx, got %08lx\n", GetLastError(), hr);
    ok(hr == TRUST_E_NOSIGNATURE || hr == CRYPT_E_FILE_ERROR,
     "expected TRUST_E_NOSIGNATURE or CRYPT_E_FILE_ERROR, got %08lx\n", hr);
    wtd.dwStateAction = WTD_STATEACTION_CLOSE;
    SetLastError(0xdeadbeef);
    r = WinVerifyTrust(INVALID_HANDLE_VALUE, &generic_action_v2, &wtd);
    ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %08lx\n", GetLastError());
    ok(r == S_OK, "WinVerifyTrust failed: %08lx\n", r);
}

Referenced by START_TEST().

test_wintrust_digest()

static void test_wintrust_digest ( void  )

static

Definition at line 1618 of file softpub.c.

{
    static const BYTE Dummy[] = { 0x11,0x22,0x33,0x44 };
    static const struct
    {
        struct { const BYTE *data; DWORD length; } blocks[5];
        struct { LONG status; BOOL todo; } t1;
        struct { LONG status; BOOL todo; } t2;
    }
    tests[] =
    {
        /* 32-bit tests */
        {
            {{ SelfSignedFile32, sizeof(SelfSignedFile32) }},
            { CERT_E_CHAINING, TRUE }, { S_OK, FALSE }
        },
        {
            {{ SelfSignedFile32, sizeof(SelfSignedFile32) },
             { Dummy, sizeof(Dummy) }},
            { TRUST_E_NOSIGNATURE, FALSE }, { TRUST_E_NOSIGNATURE, FALSE }
        },
        {
            {{ Dummy, sizeof(Dummy) },
             { SelfSignedFile32 + sizeof(Dummy), sizeof(SelfSignedFile32) - sizeof(Dummy) }},
            { TRUST_E_SUBJECT_FORM_UNKNOWN, FALSE }, { TRUST_E_NOSIGNATURE, TRUE }
        },
        {
            {{ SelfSignedFile32, 19 },
             { Dummy, sizeof(Dummy) },
             { SelfSignedFile32 + 19 + sizeof(Dummy), sizeof(SelfSignedFile32) - 19 - sizeof(Dummy) }},
            { TRUST_E_BAD_DIGEST, FALSE }, { TRUST_E_NOSIGNATURE, TRUE }
        },
        {
            {{ SelfSignedFile32, sizeof(IMAGE_DOS_HEADER) }},
            { TRUST_E_SUBJECT_FORM_UNKNOWN, TRUE }, { TRUST_E_NOSIGNATURE, FALSE }
        },
        {
            {{ SelfSignedFile32, sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS32) * 2 }},
            { TRUST_E_NOSIGNATURE, FALSE }, { TRUST_E_NOSIGNATURE, FALSE }
        },
 
        /* 64-bit tests */
        {
            {{ SelfSignedFile64, sizeof(SelfSignedFile64) }},
            { CERT_E_CHAINING, TRUE }, { S_OK, FALSE }
        },
        {
            {{ SelfSignedFile64, sizeof(SelfSignedFile64) },
             { Dummy, sizeof(Dummy) }},
            { TRUST_E_NOSIGNATURE, FALSE }, { TRUST_E_NOSIGNATURE, FALSE }
        },
        {
            {{ Dummy, sizeof(Dummy) },
             { SelfSignedFile64 + sizeof(Dummy), sizeof(SelfSignedFile64) - sizeof(Dummy) }},
            { TRUST_E_SUBJECT_FORM_UNKNOWN, FALSE }, { TRUST_E_NOSIGNATURE, TRUE }
        },
        {
            {{ SelfSignedFile64, 19 },
             { Dummy, sizeof(Dummy) },
             { SelfSignedFile64 + 19 + sizeof(Dummy), sizeof(SelfSignedFile64) - 19 - sizeof(Dummy) }},
            { TRUST_E_BAD_DIGEST, FALSE }, { TRUST_E_NOSIGNATURE, TRUE }
        },
        {
            {{ SelfSignedFile64, sizeof(IMAGE_DOS_HEADER) }},
            { TRUST_E_SUBJECT_FORM_UNKNOWN, TRUE }, { TRUST_E_NOSIGNATURE, FALSE }
        },
        {
            {{ SelfSignedFile64, sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS64) * 2 }},
            { TRUST_E_NOSIGNATURE, FALSE }, { TRUST_E_NOSIGNATURE, FALSE }
        },
    };
    WCHAR pathW[MAX_PATH];
    DWORD written;
    HANDLE file;
    LONG status;
    BOOL ret;
    int i, j;
 
    for (i = 0; i < ARRAY_SIZE(tests); i++)
    {
        file = create_temp_file(pathW);
        ok(file != INVALID_HANDLE_VALUE, "failed to create temporary file\n");
 
        for (j = 0; tests[i].blocks[j].data; j++)
        {
            ret = WriteFile(file, tests[i].blocks[j].data, tests[i].blocks[j].length, &written, NULL);
            ok(ret && written == tests[i].blocks[j].length, "WriteFile failed with %lu\n", GetLastError());
        }
 
        CloseHandle(file);
 
        call_winverify(pathW, &status, FALSE);
        todo_wine_if(tests[i].t1.todo)
        ok(status == tests[i].t1.status, "test %d/1: expected %08lx, got %08lx\n", i, tests[i].t1.status, status);
 
        call_winverify(pathW, &status, TRUE);
        todo_wine_if(tests[i].t2.todo)
        ok(status == tests[i].t2.status, "test %d/2: expected %08lx, got %08lx\n", i, tests[i].t2.status, status);
 
        DeleteFileW(pathW);
    }
}

Referenced by START_TEST().

testCertTrust()

static void testCertTrust ( SAFE_PROVIDER_FUNCTIONS *  funcs, GUID *  actionID  )

static

Definition at line 548 of file softpub.c.

{
    CRYPT_PROVIDER_DATA data = { 0 };
    CRYPT_PROVIDER_SIGSTATE sig_state = { 0 };
    CRYPT_PROVIDER_SGNR sgnr = { sizeof(sgnr), { 0 } };
    HRESULT ret;
    BOOL b;
 
    if (!CertFreeCertificateChain_p)
    {
        win_skip("CertFreeCertificateChain not found\n");
        return;
    }
 
    data.pSigState = &sig_state;
    data.padwTrustStepErrors =
     funcs->pfnAlloc(TRUSTERROR_MAX_STEPS * sizeof(DWORD));
    if (!data.padwTrustStepErrors)
    {
        skip("pfnAlloc failed\n");
        return;
    }
    ret = funcs->pfnCertificateTrust(&data);
    ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
    ok(data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV] ==
     TRUST_E_NOSIGNATURE, "Expected TRUST_E_NOSIGNATURE, got %08lx\n",
     data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_CERTPROV]);
    b = funcs->pfnAddSgnr2Chain(&data, FALSE, 0, &sgnr);
    if (b)
    {
        PCCERT_CONTEXT cert;
 
        /* An empty signer "succeeds," even though there's no cert */
        ret = funcs->pfnCertificateTrust(&data);
        ok(ret == S_OK, "Expected S_OK, got %08lx\n", ret);
        cert = CertCreateCertificateContext(X509_ASN_ENCODING, selfSignedCert,
         sizeof(selfSignedCert));
        if (cert)
        {
            WINTRUST_DATA wintrust_data = { 0 };
 
            b = funcs->pfnAddCert2Chain(&data, 0, FALSE, 0, cert);
            ok(b == TRUE, "Expected TRUE, got %d\n", b);
 
            /* If pWintrustData isn't set, crashes attempting to access
             * pWintrustData->fdwRevocationChecks
             */
            data.pWintrustData = &wintrust_data;
            /* If psPfns isn't set, crashes attempting to access
             * psPfns->pfnCertCheckPolicy
             */
            data.psPfns = (CRYPT_PROVIDER_FUNCTIONS *)funcs;
            ret = funcs->pfnCertificateTrust(&data);
            ok(ret == S_OK, "Expected S_OK, got %08lx\n", ret);
            ok(data.csSigners == 1, "Unexpected number of signers %ld\n",
             data.csSigners);
            ok(data.pasSigners[0].pChainContext != NULL,
             "Expected a certificate chain\n");
            ok(data.pasSigners[0].csCertChain == 1,
             "Unexpected number of chain elements %ld\n",
             data.pasSigners[0].csCertChain);
            /* pasSigners and pasSigners[0].pasCertChain are guaranteed to be
             * initialized, see tests for pfnAddSgnr2Chain and pfnAddCert2Chain
             */
            ok(!data.pasSigners[0].pasCertChain[0].fTrustedRoot,
             "Didn't expect cert to be trusted\n");
            ok(data.pasSigners[0].pasCertChain[0].fSelfSigned,
             "Expected cert to be self-signed\n");
            ok(data.pasSigners[0].pasCertChain[0].dwConfidence ==
             (CERT_CONFIDENCE_SIG | CERT_CONFIDENCE_TIMENEST),
             "Expected CERT_CONFIDENCE_SIG | CERT_CONFIDENCE_TIMENEST, got %08lx\n",
             data.pasSigners[0].pasCertChain[0].dwConfidence);
            CertFreeCertificateContext(
             data.pasSigners[0].pasCertChain[0].pCert);
            CertFreeCertificateChain_p(data.pasSigners[0].pChainContext);
            CertFreeCertificateContext(cert);
        }
    }
    funcs->pfnFree(data.padwTrustStepErrors);
}

Referenced by test_provider_funcs().

testInitialize()

static void testInitialize ( SAFE_PROVIDER_FUNCTIONS *  funcs, GUID *  actionID  )

static

Definition at line 229 of file softpub.c.

{
    HRESULT ret;
    CRYPT_PROVIDER_DATA data = { 0 };
    WINTRUST_DATA wintrust_data = { 0 };
 
    if (!funcs->pfnInitialize)
    {
        skip("missing pfnInitialize\n");
        return;
    }
 
    /* Crashes
    ret = funcs->pfnInitialize(NULL);
     */
    memset(&data, 0, sizeof(data));
    ret = funcs->pfnInitialize(&data);
    ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
    data.padwTrustStepErrors =
     funcs->pfnAlloc(TRUSTERROR_MAX_STEPS * sizeof(DWORD));
    /* Without wintrust data set, crashes when padwTrustStepErrors is set */
    data.pWintrustData = &wintrust_data;
    if (data.padwTrustStepErrors)
    {
        /* Apparently, cdwTrustStepErrors does not need to be set. */
        memset(data.padwTrustStepErrors, 0,
         TRUSTERROR_MAX_STEPS * sizeof(DWORD));
        ret = funcs->pfnInitialize(&data);
        ok(ret == S_OK, "Expected S_OK, got %08lx\n", ret);
        data.cdwTrustStepErrors = 1;
        ret = funcs->pfnInitialize(&data);
        ok(ret == S_OK, "Expected S_OK, got %08lx\n", ret);
        memset(data.padwTrustStepErrors, 0xba,
         TRUSTERROR_MAX_STEPS * sizeof(DWORD));
        ret = funcs->pfnInitialize(&data);
        ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
        data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_WVTINIT] = 0;
        ret = funcs->pfnInitialize(&data);
        ok(ret == S_OK, "Expected S_OK, got %08lx\n", ret);
        funcs->pfnFree(data.padwTrustStepErrors);
    }
}

testObjTrust()

static void testObjTrust ( SAFE_PROVIDER_FUNCTIONS *  funcs, GUID *  actionID  )

static

Definition at line 302 of file softpub.c.

{
    HRESULT ret;
    CRYPT_PROVIDER_DATA data = { 0 };
    CRYPT_PROVIDER_SIGSTATE sig_state = { 0 };
    WINTRUST_DATA wintrust_data = { 0 };
    WINTRUST_CERT_INFO certInfo = { sizeof(WINTRUST_CERT_INFO), 0 };
    WINTRUST_FILE_INFO fileInfo = { sizeof(WINTRUST_FILE_INFO), 0 };
 
    if (!funcs->pfnObjectTrust)
    {
        skip("missing pfnObjectTrust\n");
        return;
    }
 
    /* Crashes
    ret = funcs->pfnObjectTrust(NULL);
     */
 
    data.cbStruct = sizeof(data);
    data.pSigState = &sig_state;
    data.pWintrustData = &wintrust_data;
    data.padwTrustStepErrors =
     funcs->pfnAlloc(TRUSTERROR_MAX_STEPS * sizeof(DWORD));
    if (data.padwTrustStepErrors)
    {
        WCHAR pathW[MAX_PATH];
        PROVDATA_SIP provDataSIP = { 0 };
        static const GUID unknown = { 0xC689AAB8, 0x8E78, 0x11D0, { 0x8C,0x47,
         0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
        static GUID bogusGuid = { 0xdeadbeef, 0xbaad, 0xf00d, { 0x00,0x00,0x00,
         0x00,0x00,0x00,0x00,0x00 } };
 
        ret = funcs->pfnObjectTrust(&data);
        ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
        ok(data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         ERROR_INVALID_PARAMETER,
         "Expected ERROR_INVALID_PARAMETER, got %08lx\n",
         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV]);
        wintrust_data.pCert = &certInfo;
        wintrust_data.dwUnionChoice = WTD_CHOICE_CERT;
        ret = funcs->pfnObjectTrust(&data);
        ok(ret == S_OK, "Expected S_OK, got %08lx\n", ret);
        certInfo.psCertContext = (PCERT_CONTEXT)CertCreateCertificateContext(
         X509_ASN_ENCODING, v1CertWithPubKey, sizeof(v1CertWithPubKey));
        ret = funcs->pfnObjectTrust(&data);
        ok(ret == S_OK, "Expected S_OK, got %08lx\n", ret);
        CertFreeCertificateContext(certInfo.psCertContext);
        certInfo.psCertContext = NULL;
        wintrust_data.dwUnionChoice = WTD_CHOICE_FILE;
        wintrust_data.pFile = NULL;
        ret = funcs->pfnObjectTrust(&data);
        ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
        ok(data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         ERROR_INVALID_PARAMETER,
         "Expected ERROR_INVALID_PARAMETER, got %08lx\n",
         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV]);
        wintrust_data.pFile = &fileInfo;
        /* Crashes
        ret = funcs->pfnObjectTrust(&data);
         */
        /* Create and test with an empty file */
        fileInfo.hFile = create_temp_file(pathW);
        /* pfnObjectTrust now crashes unless both pPDSip and psPfns are set */
        data.pPDSip = &provDataSIP;
        data.psPfns = (CRYPT_PROVIDER_FUNCTIONS *)funcs;
        ret = funcs->pfnObjectTrust(&data);
        ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
        ok(data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         TRUST_E_SUBJECT_FORM_UNKNOWN,
         "expected TRUST_E_SUBJECT_FORM_UNKNOWN, got %08lx\n",
         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV]);
        CloseHandle(fileInfo.hFile);
        fileInfo.hFile = NULL;
        fileInfo.pcwszFilePath = pathW;
        ret = funcs->pfnObjectTrust(&data);
        ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
        ok(data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         TRUST_E_SUBJECT_FORM_UNKNOWN,
         "expected TRUST_E_SUBJECT_FORM_UNKNOWN, got %08lx\n",
         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV]);
        DeleteFileW(pathW);
        /* Test again with a file we expect to exist, and to contain no
         * signature.
         */
        getNotepadPath(pathW, MAX_PATH);
        ret = funcs->pfnObjectTrust(&data);
        ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
        ok(data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         TRUST_E_NOSIGNATURE ||
         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         TRUST_E_SUBJECT_FORM_UNKNOWN,
         "Expected TRUST_E_NOSIGNATURE or TRUST_E_SUBJECT_FORM_UNKNOWN, got %08lx\n",
         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV]);
        if (data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         TRUST_E_NOSIGNATURE)
        {
            ok(!memcmp(&provDataSIP.gSubject, &unknown, sizeof(unknown)),
             "Unexpected subject GUID\n");
            ok(provDataSIP.pSip != NULL, "Expected a SIP\n");
            ok(provDataSIP.psSipSubjectInfo != NULL,
             "Expected a subject info\n");
        }
        /* Specifying the GUID results in that GUID being the subject GUID */
        fileInfo.pgKnownSubject = &bogusGuid;
        ret = funcs->pfnObjectTrust(&data);
        ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
        ok(data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         TRUST_E_NOSIGNATURE ||
         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         TRUST_E_SUBJECT_FORM_UNKNOWN ||
         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         TRUST_E_PROVIDER_UNKNOWN,
         "Expected TRUST_E_NOSIGNATURE or TRUST_E_SUBJECT_FORM_UNKNOWN or TRUST_E_PROVIDER_UNKNOWN, got %08lx\n",
         data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV]);
        if (data.padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] ==
         TRUST_E_NOSIGNATURE)
        {
            ok(!memcmp(&provDataSIP.gSubject, &bogusGuid, sizeof(bogusGuid)),
             "unexpected subject GUID\n");
        }
        /* Specifying a bogus GUID pointer crashes */
        if (0)
        {
            fileInfo.pgKnownSubject = (GUID *)0xdeadbeef;
            ret = funcs->pfnObjectTrust(&data);
            ok(ret == S_FALSE, "Expected S_FALSE, got %08lx\n", ret);
        }
        funcs->pfnFree(data.padwTrustStepErrors);
    }
}

Referenced by test_provider_funcs().

VOID()

static DWORD SIP_INDIRECT_DATA *static VOID ( WINAPI *  CertFreeCertificateChain_p )

static

Variable Documentation

bin

struct _PeImage bin

static

Referenced by test_bind_image_ex(), test_get_digest_stream(), test_image_load(), test_pe_image_hash(), test_sip_create_indirect_data(), and update_checksum().

DWORD

DWORD BYTE DWORD

Definition at line 1895 of file softpub.c.

Referenced by test_utils().

self_signed_3certs

const BYTE self_signed_3certs[]

static

Definition at line 1141 of file softpub.c.

Referenced by test_multiple_signatures().

selfSignedCert

const BYTE selfSignedCert[]

static

Definition at line 434 of file softpub.c.

Referenced by testCertTrust().

SelfSignedFile32

const BYTE SelfSignedFile32[]

static

Definition at line 893 of file softpub.c.

Referenced by test_wintrust_digest().

SelfSignedFile64

const BYTE SelfSignedFile64[]

static

Definition at line 999 of file softpub.c.

Referenced by test_wintrust_digest().

usages

PCCRYPT_OID_INFO** usages

Definition at line 81 of file softpub.c.

Referenced by add_cert_to_list(), add_known_usages_to_list(), create_advanced_filter(), get_device(), initialize_purpose_selection(), test_get_known_usages(), WINTRUST_enumUsages(), and WTHelperGetKnownUsages().

v1CertWithPubKey

const BYTE v1CertWithPubKey[]

static

Initial value:

= {
0x30,0x81,0x95,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
0x67,0x00,0x30,0x22,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
0x01,0x01,0x05,0x00,0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,
0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,
0x01,0x01 }

Definition at line 112 of file softpub.c.

Referenced by test_utils(), and testObjTrust().