windows-xp/Source/XPSP1/NT/ds/win32/ntcrypto/test/testsuit/csptestsuite.h

/*

  CSPTestSuite.h

  This file contains typedef's and function prototypes for the CSP Test Suite.

  6/16/00 dangriff created

*/

#ifndef __CSPTESTSUITE__H__
#define __CSPTESTSUITE__H__

#include <windows.h>
#include <wincrypt.h>
#include "logging.h"
#include "cspstruc.h"
#include "utils.h"

#define TESTVER_MAJOR_VERSION						5
#define TESTVER_MINOR_VERSION						0

#define TEST_APP_NAME								L"CSPTestSuite"
#define MINIMUM_ARGC								3

#define CSP_TYPE_INVALID							0
#define CSP_TYPE_RSA								1
#define CSP_TYPE_DSS								2
#define CSP_TYPE_ELIPTIC_CURVE						3
#define CSP_TYPE_AES                                4

#define CLASS_INVALID								0x0
#define CLASS_SIG_ONLY								0x00000001
#define CLASS_SIG_KEYX								0x00000002
#define CLASS_FULL									0x00000004
#define CLASS_SCHANNEL								0x00000008
#define CLASS_OPTIONAL								0x00000010

static DWORD g_rgCspClasses [] = { 
	CLASS_SIG_ONLY, CLASS_SIG_KEYX, CLASS_FULL, CLASS_OPTIONAL 
};

#define TEST_LEVEL_CSP								0x1
#define TEST_LEVEL_PROV								0x2
#define TEST_LEVEL_HASH								0x4
#define TEST_LEVEL_KEY								0x8
#define TEST_LEVEL_CONTAINER						0x10

static DWORD g_rgTestLevels [] = { 
	TEST_LEVEL_CSP, TEST_LEVEL_PROV, TEST_LEVEL_HASH, TEST_LEVEL_KEY, TEST_LEVEL_CONTAINER 
};

// 
// Parameters used by the test cases
//
#define BUFFER_SIZE									2048
#define TEST_MAX_RSA_KEYSIZE						1024
#define TEST_INVALID_FLAG							-1
#define TEST_INVALID_HANDLE							-1
#define TEST_INVALID_POINTER						-1
#define GENRANDOM_BYTE_COUNT						1000
#define TEST_HASH_DATA								L"Test hash data"
#define TEST_DECRYPT_DATA							L"Test decrypt data"
#define HASH_LENGTH_SHA1							20
#define HASH_LENGTH_MD5								16
#define TEST_CIPHER_LENGTH_RC4						256
#define TEST_RC2_DATA_LEN							8
#define TEST_RC2_BUFFER_LEN							16
#define TEST_CRYPTACQUIRECONTEXT_CONTAINER			L"TestingCAC"
#define TEST_CONTAINER								L"TestSuiteContainer"
#define TEST_CONTAINER_2							L"TestSuiteContainer2"
#define TEST_SALT_BYTE								0xcd
#define TEST_IV_BYTE								0xcd
#define TEST_SALT_LEN								20
#define TEST_EFFECTIVE_KEYLEN						56
#define TEST_MODE_BITS								16


//
// ------------------------
// Known Error Lookup Table
// ------------------------
//
static KNOWN_ERROR_INFO g_KnownErrorTable[] =
{
	//
	// Known errors in Positive test cases
	//
	/*
		KnownErrorID					Maj		Min	SP	SP				Actual Error Level
										Rev		Rev	Maj	Min
	*/
	{ KNOWN_CRYPTGETPROVPARAM_MAC,			5,	0,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTGETPROVPARAM_PPNAME,		5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTSETKEYPARAM_EXPORT,		5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTGETKEYPARAM_SALT,			5,	0,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTGENKEY_SALTDES,			5,	1,	0,	0,			CSP_ERROR_WARNING },

	// 
	// Known errors in Negative test cases
	//
	{ KNOWN_CRYPTACQUIRECONTEXT_NULLPHPROV, 5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTACQUIRECONTEXT_BADFLAGS,	5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_ERRORINVALIDHANDLE,				5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTGETPROVPARAM_MOREDATA,		5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTSETPROVPARAM_RNG,			5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTSETPROVPARAM_BADFLAGS,		5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTCREATEHASH_BADKEY,			5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTIMPORTKEY_BADFLAGS,		5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTIMPORTKEY_BADALGID,		5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_NTEBADKEY,						5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_NTEBADHASH,						5,	1,	0,	0,			CSP_ERROR_WARNING },
	{ KNOWN_CRYPTGENKEY_SILENTCONTEXT,		5,	0,	0,	0,			CSP_ERROR_WARNING },

	//
	// Known errors in Scenario test cases
	//
	{ KNOWN_TESTDECRYPTPROC_3DES112,		5,	0,	0,	0,			CSP_ERROR_WARNING }
};

//
// Function: GetKnownErrorValue
// Purpose: Lookup a known error in the g_KnownErrorTable.  The return value
// is the actual error value that should be applied to the current error.
// 1) If the error is not in the table, return the dwCurrentErrorLevel param
// 2) If the error is found in the table, get the error level that should be 
// applied to that error from the table.  
//
// If the version information for 
// the known error matches that of this NT system, return the error level as 
// is.  Otherwise, increment the error level, since it is expected to have
// been fixed by now.
//
DWORD GetKnownErrorValue(
		IN KNOWN_ERROR_ID KnownErrorID,
		IN DWORD dwCurrentErrorLevel);

//
// Struct: CSPTYPEMAP
// Purpose: This struct is used to map external provider types (a subset of those 
// defined in wincrypt.h) to internal provider classes.
//
typedef struct _CSPTYPEMAP
{
	DWORD dwExternalProvType;
	DWORD dwProvType;
	DWORD dwCSPClass;
	LPWSTR pwszExternalProvType;
} CSPTYPEMAP, *PCSPTYPEMAP;

static CSPTYPEMAP g_CspTypeTable [] =
{
	/*
		ExternalProvType	InternalProvType	InternalCSPClass	External Type Description
	*/
	{ PROV_RSA_FULL,		CSP_TYPE_RSA,		CLASS_FULL,			L"PROV_RSA_FULL" },
	{ PROV_RSA_SIG,			CSP_TYPE_RSA,		CLASS_SIG_ONLY,		L"PROV_RSA_SIG" },
	{ PROV_DSS,				CSP_TYPE_DSS,		CLASS_SIG_ONLY,		L"PROV_DSS" },
	{ PROV_DSS_DH,			CSP_TYPE_DSS,		CLASS_FULL,			L"PROV_DSS_DH" },
    { PROV_RSA_AES,         CSP_TYPE_AES,       CLASS_FULL,         L"PROV_RSA_AES" }
};

typedef struct _ALGID_TABLE
{
	DWORD dwCSPClass;
	ALG_ID ai;
} ALGID_TABLE, *PALGID_TABLE;

static ALGID_TABLE g_RequiredAlgs_RSA[] = 
{
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_RSA_SIGN },
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_SHA1 },
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_MD5 },
	{ CLASS_SIG_KEYX | CLASS_FULL,						CALG_RSA_KEYX },
	{ CLASS_FULL,										CALG_RC2 },
	{ CLASS_FULL,										CALG_RC4 }
};

static ALGID_TABLE g_OtherKnownAlgs_RSA[] = 
{ 
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_MD2 },
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_MD4 },
	{ CLASS_FULL,										CALG_MAC },
	{ CLASS_FULL,										CALG_HMAC },
	{ CLASS_FULL,										CALG_DES },
	{ CLASS_FULL,										CALG_3DES_112 }, 
	{ CLASS_FULL,										CALG_3DES }
};

static ALGID_TABLE g_RequiredAlgs_AES[] = 
{
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_RSA_SIGN },
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_SHA1 },
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_MD5 },
	{ CLASS_SIG_KEYX | CLASS_FULL,						CALG_RSA_KEYX },
	{ CLASS_FULL,										CALG_RC2 },
	{ CLASS_FULL,										CALG_RC4 },
    { CLASS_FULL,                                       CALG_AES_128 },
    { CLASS_FULL,                                       CALG_AES_192 },
    { CLASS_FULL,                                       CALG_AES_256 }
};

static ALGID_TABLE g_OtherKnownAlgs_AES[] = 
{ 
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_MD2 },
	{ CLASS_SIG_ONLY | CLASS_SIG_KEYX | CLASS_FULL,		CALG_MD4 },
	{ CLASS_FULL,										CALG_MAC },
	{ CLASS_FULL,										CALG_HMAC },
	{ CLASS_FULL,										CALG_DES },
	{ CLASS_FULL,										CALG_3DES_112 }, 
	{ CLASS_FULL,										CALG_3DES }
};

//
// Function: IsRequiredAlg
// Purpose: Search the RequiredAlgs array for the specified algorithm, ai.
// If ai is found, return TRUE, otherwise return FALSE.
//
BOOL IsRequiredAlg(ALG_ID ai, DWORD dwInternalProvType);

// 
// Function: IsKnownAlg
// Purpose: Search the OtherKnownAlgs array for the specified algorithm, ai.
// If ai is found, return TRUE, otherwise return FALSE.
//
BOOL IsKnownAlg(ALG_ID ai, DWORD dwInternalProvType);

//
// ------------------
// CSP Test Functions
// ------------------
//
BOOL TestBuildAlgList(PCSPINFO pCSPInfo);

BOOL PositiveAcquireContextTests(PCSPINFO pCSPInfo);
BOOL NegativeAcquireContextTests(PCSPINFO pCSPInfo);
BOOL PositiveGetProvParamTests(PCSPINFO pCSPInfo);
BOOL NegativeGetProvParamTests(PCSPINFO pCSPInfo);
BOOL PositiveSetProvParamTests(PCSPINFO pCSPInfo);
BOOL NegativeSetProvParamTests(PCSPINFO pCSPInfo);
BOOL PositiveReleaseContextTests(PCSPINFO pCSPInfo);
BOOL NegativeReleaseContextTests(PCSPINFO pCSPInfo);

BOOL PositiveGenRandomTests(PCSPINFO pCSPInfo);
BOOL NegativeGenRandomTests(PCSPINFO pCSPInfo);

BOOL PositiveCreateHashTests(PCSPINFO pCSPInfo);
BOOL NegativeCreateHashTests(PCSPINFO pCSPInfo);
BOOL PositiveDestroyHashTests(PCSPINFO pCSPInfo);
BOOL NegativeDestroyHashTests(PCSPINFO pCSPInfo);
BOOL PositiveGetHashParamTests(PCSPINFO pCSPInfo);
BOOL NegativeGetHashParamTests(PCSPINFO pCSPInfo);
BOOL PositiveHashDataTests(PCSPINFO pCSPInfo);
BOOL NegativeHashDataTests(PCSPINFO pCSPInfo);
BOOL PositiveSetHashParamTests(PCSPINFO pCSPInfo);
BOOL NegativeSetHashParamTests(PCSPINFO pCSPInfo);

BOOL PositiveDestroyKeyTests(PCSPINFO pCSPInfo);
BOOL NegativeDestroyKeyTests(PCSPINFO pCSPInfo);
BOOL PositiveGetKeyParamTests(PCSPINFO pCSPInfo);
BOOL NegativeGetKeyParamTests(PCSPINFO pCSPInfo);
BOOL PositiveSetKeyParamTests(PCSPINFO pCSPInfo);
BOOL NegativeSetKeyParamTests(PCSPINFO pCSPInfo);
BOOL PositiveDecryptTests(PCSPINFO pCSPInfo);
BOOL NegativeDecryptTests(PCSPINFO pCSPInfo);
BOOL PositiveEncryptTests(PCSPINFO pCSPInfo);
BOOL NegativeEncryptTests(PCSPINFO pCSPInfo);
BOOL PositiveGenKeyTests(PCSPINFO pCSPInfo);
BOOL NegativeGenKeyTests(PCSPINFO pCSPInfo);
BOOL PositiveDeriveKeyTests(PCSPINFO pCSPInfo);
BOOL NegativeDeriveKeyTests(PCSPINFO pCSPInfo);
BOOL PositiveHashSessionKeyTests(PCSPINFO pCSPInfo);
BOOL NegativeHashSessionKeyTests(PCSPINFO pCSPInfo);

BOOL PositiveExportKeyTests(PCSPINFO pCSPInfo);
BOOL NegativeExportKeyTests(PCSPINFO pCSPInfo);
BOOL PositiveGetUserKeyTests(PCSPINFO pCSPInfo);
BOOL NegativeGetUserKeyTests(PCSPINFO pCSPInfo);
BOOL PositiveImportKeyTests(PCSPINFO pCSPInfo);
BOOL NegativeImportKeyTests(PCSPINFO pCSPInfo);
BOOL PositiveSignHashTests(PCSPINFO pCSPInfo);
BOOL NegativeSignHashTests(PCSPINFO pCSPInfo);
BOOL PositiveVerifySignatureTests(PCSPINFO pCSPInfo);
BOOL NegativeVerifySignatureTests(PCSPINFO pCSPInfo);

BOOL ScenarioDecryptTests(PCSPINFO pCSPInfo);
BOOL ScenarioImportKeyTests(PCSPINFO pCSPInfo);
BOOL ScenarioVerifySignatureTests(PCSPINFO pCSPInfo);
BOOL ScenarioKeyExchangeTests(PCSPINFO pCSPInfo);

BOOL InteropHashDataTests(PCSPINFO pCSPInfo);
BOOL InteropDecryptTests(PCSPINFO pCSPInfo);
BOOL InteropDeriveKeyTests(PCSPINFO pCSPInfo);
BOOL InteropHashSessionKeyTests(PCSPINFO pCSPInfo);
BOOL InteropKeyExchangeTests(PCSPINFO pCSPInfo);

//
// --------------------------
// CSP Test Function Matrices
// --------------------------
//

//
// Struct: TESTTABLEENTRY
// Purpose: This struct will be used to store the static table below, which
// will map test functions that should be called for each relevant 
// [ Test Class , Test Level ] combination.
//

typedef struct _TESTTABLEENTRY
{
	PFN_CSPTEST pTestFunc;
	DWORD dwClassSigOnly;
	DWORD dwClassSigKeyX;
	DWORD dwClassFull;
	DWORD dwClassOptional;
	API_NAME ApiName;
	DWORD dwTestType;
} TESTTABLEENTRY, *PTESTTABLEENTRY;

//
// A table of test functions and the 
// CSP Classes and Test Levels to which each function applies.
//
static TESTTABLEENTRY g_TestFunctionMappings[] = 
{
	/*
		Function-					CLASS_SIG_ONLY			CLASS_SIG_KEYX		CLASS_FULL		CLASS_OPTIONAL		dwAPI				dwTestType
		name
	*/

	// TEST_LEVEL_CSP major group
	{	PositiveAcquireContextTests, TEST_LEVEL_CSP | TEST_LEVEL_CONTAINER,	0,	0,				0, API_CRYPTACQUIRECONTEXT, TEST_CASES_POSITIVE },
	{	NegativeAcquireContextTests, TEST_LEVEL_CSP | TEST_LEVEL_CONTAINER, 0,	0,				0,	API_CRYPTACQUIRECONTEXT, TEST_CASES_NEGATIVE },
	{	PositiveGetProvParamTests,	TEST_LEVEL_CSP,			0,					0,				0, API_CRYPTGETPROVPARAM, TEST_CASES_POSITIVE },
	{	NegativeGetProvParamTests,	TEST_LEVEL_CSP,			0,					0,				0, API_CRYPTGETPROVPARAM, TEST_CASES_NEGATIVE },
	{	PositiveSetProvParamTests,	TEST_LEVEL_CSP,			0,					0,				0, API_CRYPTSETPROVPARAM, TEST_CASES_POSITIVE },
	{	NegativeSetProvParamTests,	TEST_LEVEL_CSP,			0,					0,				0, API_CRYPTSETPROVPARAM, TEST_CASES_NEGATIVE },
	{	PositiveReleaseContextTests, TEST_LEVEL_CSP,		0,					0,				0, API_CRYPTRELEASECONTEXT, TEST_CASES_POSITIVE },
	{	NegativeReleaseContextTests, TEST_LEVEL_CSP,		0,					0,				0, API_CRYPTRELEASECONTEXT, TEST_CASES_NEGATIVE },

	// TEST_LEVEL_PROV major group
	{	PositiveGenRandomTests,		0,						0,					0,				TEST_LEVEL_PROV, API_CRYPTGENRANDOM, TEST_CASES_POSITIVE },
	{	NegativeGenRandomTests,		0,						0,					0,				TEST_LEVEL_PROV, API_CRYPTGENRANDOM, TEST_CASES_NEGATIVE },

	// TEST_LEVEL_HASH major group
	{	PositiveCreateHashTests,	TEST_LEVEL_HASH,		0,					0,				TEST_LEVEL_HASH, API_CRYPTCREATEHASH, TEST_CASES_POSITIVE },
	{	NegativeCreateHashTests,	TEST_LEVEL_HASH,		0,					0,				TEST_LEVEL_HASH, API_CRYPTCREATEHASH, TEST_CASES_NEGATIVE },
	{	PositiveDestroyHashTests,	TEST_LEVEL_HASH,		0,					0,				0, API_CRYPTDESTROYHASH, TEST_CASES_POSITIVE },
	{	NegativeDestroyHashTests,	TEST_LEVEL_HASH,		0,					0,				0, API_CRYPTDESTROYHASH, TEST_CASES_NEGATIVE },
	{	PositiveGetHashParamTests,	TEST_LEVEL_HASH,		0,					0,				0, API_CRYPTGETHASHPARAM, TEST_CASES_POSITIVE },
	{	NegativeGetHashParamTests,	TEST_LEVEL_HASH,		0,					0,				0, API_CRYPTGETHASHPARAM, TEST_CASES_NEGATIVE },
	{	PositiveHashDataTests,		TEST_LEVEL_HASH,		0,					0,				0, API_CRYPTHASHDATA, TEST_CASES_POSITIVE },
	{	NegativeHashDataTests,		TEST_LEVEL_HASH,		0,					0,				0, API_CRYPTHASHDATA, TEST_CASES_NEGATIVE },
	{	PositiveSetHashParamTests,	TEST_LEVEL_HASH,		0,					0,				0, API_CRYPTSETHASHPARAM, TEST_CASES_POSITIVE },
	{	NegativeSetHashParamTests,	TEST_LEVEL_HASH,		0,					0,				0, API_CRYPTSETHASHPARAM, TEST_CASES_NEGATIVE },

	// TEST_LEVEL_KEY major group
	{	PositiveDestroyKeyTests,	TEST_LEVEL_KEY,			0,					0,				0, API_CRYPTDESTROYKEY, TEST_CASES_POSITIVE },
	{	NegativeDestroyKeyTests,	TEST_LEVEL_KEY,			0,					0,				0, API_CRYPTDESTROYKEY, TEST_CASES_NEGATIVE },
	{	PositiveGetKeyParamTests,	TEST_LEVEL_KEY,			0,					0,				0, API_CRYPTGETKEYPARAM, TEST_CASES_POSITIVE },
	{	NegativeGetKeyParamTests,	TEST_LEVEL_KEY,			0,					0,				0, API_CRYPTGETKEYPARAM, TEST_CASES_NEGATIVE },
	{	PositiveSetKeyParamTests,	TEST_LEVEL_KEY,			0,					0,				0, API_CRYPTSETKEYPARAM, TEST_CASES_POSITIVE },
	{	NegativeSetKeyParamTests,	TEST_LEVEL_KEY,			0,					0,				0, API_CRYPTSETKEYPARAM, TEST_CASES_NEGATIVE },
	{	PositiveDecryptTests,		0,						0,					TEST_LEVEL_KEY, 0, API_CRYPTDECRYPT, TEST_CASES_POSITIVE },
	{	NegativeDecryptTests,		0,						0,					TEST_LEVEL_KEY, 0, API_CRYPTDECRYPT, TEST_CASES_NEGATIVE },
	{	PositiveEncryptTests,		0,						0,					TEST_LEVEL_KEY, 0, API_CRYPTENCRYPT, TEST_CASES_POSITIVE },
	{	NegativeEncryptTests,		0,						0,					TEST_LEVEL_KEY, 0, API_CRYPTENCRYPT, TEST_CASES_NEGATIVE },
	{	PositiveGenKeyTests,		TEST_LEVEL_CONTAINER,	TEST_LEVEL_CONTAINER, TEST_LEVEL_KEY, TEST_LEVEL_KEY | TEST_LEVEL_CONTAINER, API_CRYPTGENKEY, TEST_CASES_POSITIVE },
	{	NegativeGenKeyTests,		TEST_LEVEL_CONTAINER,	0,					TEST_LEVEL_KEY, 0, API_CRYPTGENKEY, TEST_CASES_NEGATIVE },
	{	PositiveDeriveKeyTests,		0,						0,					0,				TEST_LEVEL_KEY | TEST_LEVEL_CONTAINER, API_CRYPTDERIVEKEY, TEST_CASES_POSITIVE },
	{	NegativeDeriveKeyTests,		0,						0,					0,				TEST_LEVEL_KEY, API_CRYPTDERIVEKEY, TEST_CASES_NEGATIVE },
	{	PositiveHashSessionKeyTests, 0,						0,					0,				TEST_LEVEL_KEY, API_CRYPTHASHSESSIONKEY, TEST_CASES_POSITIVE },
	{	NegativeHashSessionKeyTests, 0,						0,					0,				TEST_LEVEL_KEY, API_CRYPTHASHSESSIONKEY, TEST_CASES_NEGATIVE },

	// TEST_LEVEL_CONTAINER major group
	{	PositiveExportKeyTests,		TEST_LEVEL_CONTAINER,	TEST_LEVEL_CONTAINER, 0,			0, API_CRYPTEXPORTKEY, TEST_CASES_POSITIVE },
	{	NegativeExportKeyTests,		TEST_LEVEL_CONTAINER,	TEST_LEVEL_CONTAINER, 0,			0, API_CRYPTEXPORTKEY, TEST_CASES_NEGATIVE },
	{	PositiveGetUserKeyTests,	TEST_LEVEL_CONTAINER,	TEST_LEVEL_CONTAINER, 0,			0, API_CRYPTGETUSERKEY, TEST_CASES_POSITIVE },
	{	NegativeGetUserKeyTests,	TEST_LEVEL_CONTAINER,	TEST_LEVEL_CONTAINER, 0,			0, API_CRYPTGETUSERKEY, TEST_CASES_NEGATIVE },
	{	PositiveImportKeyTests,		TEST_LEVEL_CONTAINER,	TEST_LEVEL_CONTAINER, 0,				0, API_CRYPTIMPORTKEY, TEST_CASES_POSITIVE },
	{	NegativeImportKeyTests,		TEST_LEVEL_CONTAINER,	TEST_LEVEL_CONTAINER, 0,				0, API_CRYPTIMPORTKEY, TEST_CASES_NEGATIVE },
	{	PositiveSignHashTests,		TEST_LEVEL_CONTAINER,	TEST_LEVEL_CONTAINER, 0,				0, API_CRYPTSIGNHASH, TEST_CASES_POSITIVE },
	{	NegativeSignHashTests,		TEST_LEVEL_CONTAINER,	0,					0,				0, API_CRYPTSIGNHASH, TEST_CASES_NEGATIVE },
	{	PositiveVerifySignatureTests, TEST_LEVEL_CONTAINER, TEST_LEVEL_CONTAINER, 0,			0, API_CRYPTVERIFYSIGNATURE, TEST_CASES_POSITIVE },
	{	NegativeVerifySignatureTests, TEST_LEVEL_CONTAINER,	0,					0,				0, API_CRYPTVERIFYSIGNATURE, TEST_CASES_NEGATIVE }
};

typedef struct _BASIC_TEST_TABLE
{
	PFN_CSPTEST pTestFunc;
	LPWSTR pwszDescription;
} BASIC_TEST_TABLE, *PBASIC_TEST_TABLE;

//
// A table of Scenario Test functions
//
static BASIC_TEST_TABLE g_ScenarioTestTable [] = 
{
	{ TestBuildAlgList,				L"Build a list a supported algorithms" },
	{ ScenarioDecryptTests,			L"Decryption/encryption test scenario" },
	{ ScenarioImportKeyTests,		L"Key import/export test scenario" },
	{ ScenarioVerifySignatureTests, L"Data signature/verification test scenario" },
	{ ScenarioKeyExchangeTests,		L"RSA Key exchange test scenario" }
};

//
// A table of Interop Test functions
//
static BASIC_TEST_TABLE g_InteropTestTable [] =
{
	{ TestBuildAlgList,				L"Build a list a supported algorithms" },
	{ InteropHashDataTests,			L"Hashed data interop test" },
	{ InteropDecryptTests,			L"Decryption/encryption interop test" },
	{ InteropDeriveKeyTests,		L"Key derivation interop test" },
	{ InteropHashSessionKeyTests,	L"Hashed session key interop test" },
	{ InteropKeyExchangeTests,		L"RSA Key exchange interop test" }
};

//
// ----------------
// General Routines
// ----------------
//

//
// Function: GetNextRegisteredCSP
// Purpose: In successive calls, enumerates all of the registered CSP's
// on the system, if the ENUMERATE_REGISTERED_CSP flag is specified in 
// dwRequestedIndex.  Otherwise, the provider at index dwRequestedIndex
// is returned.
//
// Note: Do not mix enumerating all CSP's with a call using the 
// ENUMERATE_REGISTERED_CSP flag, or some of the CSP's may not 
// be enumerated.
//
#define ENUMERATE_REGISTERED_CSP		-1

DWORD GetNextRegisteredCSP(
		OUT LPWSTR pwszCsp, 
		IN OUT PDWORD cbCsp,
		OUT PDWORD pdwProvType,
		IN DWORD dwRequestedIndex);

//
// -------------------------------
// API Test Helpers
// Struct's and Callback functions
// -------------------------------
//

//
// Function: TAcquire
// Purpose: Call CryptAcquireContext with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TAcquire(
		HCRYPTPROV *phProv, 
		LPWSTR pszContainer, 
		LPWSTR pszProvider, 
		DWORD dwProvType, 
		DWORD dwFlags, 
		PTESTCASE ptc);

//
// Function: TGetProv
// Purpose: Call CryptGetProvParam with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TGetProv(
		HCRYPTPROV hProv,
		DWORD dwParam,
		BYTE *pbData,
		DWORD *pdwDataLen,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Function: TSetProv
// Purpose: Call CryptSetProvParam with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TSetProv(
		HCRYPTPROV hProv,
		DWORD dwParam,
		BYTE *pbData,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Function: TRelease
// Purpose: Call CryptReleaseContext with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TRelease(
		HCRYPTPROV hProv,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Function: TGenRand
// Purpose: Call CryptGenRandom with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TGenRand(
		HCRYPTPROV hProv,
		DWORD dwLen,
		BYTE *pbBuffer,
		PTESTCASE ptc);

//
// Function: TCreateHash
// Purpose: Call CryptCreateHash with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TCreateHash(
		HCRYPTPROV hProv,
		ALG_ID Algid,
		HCRYPTKEY hKey,
		DWORD dwFlags,
		HCRYPTHASH *phHash,
		PTESTCASE ptc);

//
// Function: TDestroyHash
// Purpose: Call CryptDestroyHash with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TDestroyHash(
		HCRYPTHASH hHash,
		PTESTCASE ptc);

//
// Function: TDuplicateHash
// Purpose: Call CryptDuplicateHash with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TDuplicateHash(
		HCRYPTHASH hHash,
		DWORD *pdwReserved,
		DWORD dwFlags,
		HCRYPTHASH *phHash,
		PTESTCASE ptc);

//
// Function: TGetHash
// Purpose: Call CryptGetHashParam with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TGetHash(
		HCRYPTHASH hHash,
		DWORD dwParam,
		BYTE *pbData,
		DWORD *pdwDataLen,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Function: THashData
// Purpose: Call CryptHashData with the supplied parameters and pass
// the result to the logging routine.
//
BOOL THashData(
		HCRYPTHASH hHash,
		BYTE *pbData,
		DWORD dwDataLen,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Function: TSetHash
// Purpose: Call CryptSetHashParam with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TSetHash(
		HCRYPTHASH hHash,
		DWORD dwParam,
		BYTE *pbData,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Function: TDecrypt
// Purpose: Call CryptDecrypt with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TDecrypt(
		HCRYPTKEY hKey,
		HCRYPTHASH hHash,
		BOOL Final,
		DWORD dwFlags,
		BYTE *pbData,
		DWORD *pdwDataLen,
		PTESTCASE ptc);

//
// Function: TDeriveKey
// Purpose: Call CryptDeriveKey with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TDeriveKey(
		HCRYPTPROV hProv,
		ALG_ID Algid,
		HCRYPTHASH hBaseData,
		DWORD dwFlags,
		HCRYPTKEY *phKey,
		PTESTCASE ptc);

//
// Function: TDestroyKey
// Purpose: Call CryptDestroyKey with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TDestroyKey(
		HCRYPTKEY hKey,
		PTESTCASE ptc);

//
// Function: TEncrypt
// Purpose: Call CryptEncrypt with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TEncrypt(
		HCRYPTKEY hKey,
		HCRYPTHASH hHash, 
		BOOL Final,
		DWORD dwFlags,
		BYTE *pbData,
		DWORD *pdwDataLen,
		DWORD dwBufLen,
		PTESTCASE ptc);

//
// Function: TGenKey
// Purpose: Call CryptGenKey with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TGenKey(
		HCRYPTPROV hProv,
		ALG_ID Algid,
		DWORD dwFlags,
		HCRYPTKEY *phKey,
		PTESTCASE ptc);

//
// Function: TGetKey
// Purpose: Call CryptGetKeyParam with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TGetKey(
		HCRYPTKEY hKey,
		DWORD dwParam,
		BYTE *pbData,
		DWORD *pdwDataLen,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Function: THashSession
// Purpose: Call CryptHashSessionKey with the supplied parameters and pass
// the result to the logging routine.
//
BOOL THashSession(
		HCRYPTHASH hHash,
		HCRYPTKEY hKey,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Function: TSetKey
// Purpose: Call CryptSetKeyParam with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TSetKey(
		HCRYPTKEY hKey,
		DWORD dwParam,
		BYTE *pbData,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Function: TExportKey
// Purpose: Call CryptExportKey with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TExportKey(
		HCRYPTKEY hKey,
		HCRYPTKEY hExpKey,
		DWORD dwBlobType,
		DWORD dwFlags,
		BYTE *pbData,
		DWORD *pdwDataLen,
		PTESTCASE ptc);

//
// Function: TGetUser
// Purpose: Call CryptGetUserKey with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TGetUser(
		HCRYPTPROV hProv,
		DWORD dwKeySpec,
		HCRYPTKEY *phUserKey,
		PTESTCASE ptc);

//
// Function: TImportKey
// Purpose: Call CryptImportKey with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TImportKey(
		HCRYPTPROV hProv,
		BYTE *pbData,
		DWORD dwDataLen,
		HCRYPTKEY hPubKey,
		DWORD dwFlags,
		HCRYPTKEY *phKey,
		PTESTCASE ptc);

//
// Function: TSignHash
// Purpose: Call CryptSignHash with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TSignHash(
		HCRYPTHASH hHash,
		DWORD dwKeySpec,
		LPWSTR sDescription,
		DWORD dwFlags,
		BYTE *pbSignature,
		DWORD *pdwSigLen,
		PTESTCASE ptc);

//
// Function: TVerifySign
// Purpose: Call CryptVerifySign with the supplied parameters and pass
// the result to the logging routine.
//
BOOL TVerifySign(
		HCRYPTHASH hHash,
		BYTE *pbSignature,
		DWORD dwSigLen,
		HCRYPTKEY hPubKey,
		LPWSTR sDescription,
		DWORD dwFlags,
		PTESTCASE ptc);

//
// Struct: TEST_CREATE_HASH_INFO
// Purpose: Store data for calls to TestCreateHashProc
//
typedef struct _TEST_CREATE_HASH_INFO
{
	HCRYPTPROV hProv;
	HCRYPTKEY hBlockCipherKey;
} TEST_CREATE_HASH_INFO, *PTEST_CREATE_HASH_INFO;

//
// Struct: TEST_HASH_DATA_INFO
// Purpose: Store data that will be common to all calls to TestHashDataProc
//
typedef struct _TEST_HASH_DATA_INFO
{
	HCRYPTPROV hProv;
	HCRYPTPROV hInteropProv;
	DATA_BLOB dbBaseData;

	//
	// These parameters are only used when this structure
	// is passed to TestMacDataProc
	//
	PALGNODE pAlgList;
	HMAC_INFO HmacInfo;
	ALG_ID aiMac;
} TEST_HASH_DATA_INFO, *PTEST_HASH_DATA_INFO;

//
// Function: TestHashDataProc
// Purpose: Create a hash context of the algorithm supplied in the
// pAlgNode parameter.  Hash some test data.  Verify that the hash result
// is the same as what is reported by the interop CSP
//
BOOL TestHashDataProc(
		PALGNODE pAlgNode, 
		PTESTCASE ptc, 
		PVOID pvTestHashDataInfo);

//
// Struct: TEST_DECRYPT_INFO
// Purpose: Store data to be passed to TestDecryptProc via 
// AlgListIterate.
//
typedef struct _TEST_DECRYPT_INFO
{
	HCRYPTPROV hProv;
	HCRYPTPROV hInteropProv;

	//
	// fDecrypt
	// If False, test CryptEncrypt
	// If True, test CryptDecrypt
	//
	BOOL fDecrypt;
} 
TEST_DECRYPT_INFO, *PTEST_DECRYPT_INFO;

//
// Function: TestDecryptProc
// Purpose: A callback function for AlgListIterate.  For each 
// encryption algorithm supported by the CSP under test, this
// function will be called to test decryption functionality.
//
BOOL TestDecryptProc(
		PALGNODE pAlgNode,
		PTESTCASE ptc,
		PVOID pvTestDecryptInfo);

//
// Struct: TEST_DERIVE_KEY_INFO
// Purpose: Store data to be passed to TestDeriveKeyProc via 
// AlgListIterate.
//
typedef struct _TEST_DERIVE_KEY_INFO
{
	HCRYPTPROV hProv;
	HCRYPTPROV hInteropProv;
} TEST_DERIVE_KEY_INFO, *PTEST_DERIVE_KEY_INFO;

//
// Function: TestDeriveKeyProc
// Purpose: Callback function for testing CryptDeriveKey using
// AlgListIterate.  For each session key algorithm supported by the
// target CSP, this function will be called to test CryptDeriveKey
// functionality.
//
BOOL TestDeriveKeyProc(
		PALGNODE pAlgNode,
		PTESTCASE ptc,
		PVOID pvTestDeriveKeyInfo);

//
// Struct: TEST_GEN_KEY_INFO
// Purpose: Data that must be provided to the TestGenKeyProc function.
//
typedef struct _TEST_GEN_KEY_INFO
{
	HCRYPTPROV hProv;
	HCRYPTPROV hNotSilentProv;
	PCSPINFO pCSPInfo;
} TEST_GEN_KEY_INFO, *PTEST_GEN_KEY_INFO;

//
// Function: TestGenKeyProc
// Purpose: Callback function for testing CryptGenKey using
// AlgListIterate.  For each key algorithm supported by the target
// CSP, this function will be called.
//
BOOL TestGenKeyProc(
		PALGNODE pAlgNode,
		PTESTCASE ptc,
		PVOID pvhProv);

//
// Struct: TEST_HASH_SESSION_KEY
// Purpose: Data that must be provided to the TestHashSessionKeyProc function.
//
typedef struct _TEST_HASH_SESSION_KEY
{
	HCRYPTPROV hProv;
	HCRYPTPROV hInteropProv;
	ALG_ID aiHash;
} TEST_HASH_SESSION_KEY, *PTEST_HASH_SESSION_KEY;

//
// Function: TestHashSessionKeyProc
// Purpose: Callback function for testing CryptHashSessionKey
// using AlgListIterate.  For each session key algorithm 
// supported by the target CSP, this function will be called.
//
BOOL TestHashSessionKeyProc(
		PALGNODE pAlgNode,
		PTESTCASE ptc,
		PVOID pvTestHashSessionKey);

//
// -----------------------------------------
// Defines for testing key Import and Export
// -----------------------------------------
//
typedef struct _KEY_EXPORT_INFO
{
	HCRYPTPROV hProv;
	ALG_ID aiKey;
	DWORD dwKeySize;
	DWORD dwExportFlags;
	PALGNODE pAlgList;

	//
	// For PRIVATEKEYBLOB scenarios, the use of an encryption key
	// is optional, since exporting unencrypted PRIVATEKEYBLOB's is 
	// supported.
	//
	BOOL fUseEncryptKey;
	ALG_ID aiEncryptKey;
	DWORD dwEncryptKeySize;
} KEY_EXPORT_INFO, *PKEY_EXPORT_INFO;

//
// Function: TestPrivateKeyBlobProc
// Purpose: Create a public/private key pair.  Export the public key as a PRIVATEKEYBLOB
// structure.  Verify that the key blob can be successfully re-imported.
//
BOOL TestPrivateKeyBlobProc(
		PALGNODE pAlgNode,
		PTESTCASE ptc,
		PVOID pvKeyExportInfo);

//
// Function: TestSymmetricWrapKeyBlobProc
// Purpose: Create a session key.  Export the session key encrypted
// with another session key.  Verify that the first session key can
// be re-imported.
//
BOOL TestSymmetricWrapKeyBlobProc(
		PALGNODE pAlgNode,
		PTESTCASE ptc,
		PVOID pvKeyExportInfo);

//
// -----------------------------------------
// Defines for testing key Import and Export
// -----------------------------------------
//

//
// Struct: SIGN_HASH_INFO
// Purpose: Test case data for creating and signing a hash
//
typedef struct _SIGN_HASH_INFO
{
	HCRYPTPROV hProv;
	HCRYPTKEY hSigKey;
	HCRYPTKEY hExchKey;
	DATA_BLOB dbBaseData;
} SIGN_HASH_INFO, *PSIGN_HASH_INFO;

//
// Function: SignAndVerifySignatureProc
// Purpose: Create a hash of the requested type and hash some test data.
// Sign and verify the signature of the hash with both the Signature and
// Key Exchange key pairs.
//
BOOL SignAndVerifySignatureProc(
		PALGNODE pAlgNode,
		PTESTCASE ptc,
		PVOID pvSignHashInfo);

//
// -------------------------------------------
// Defines for testing a Key Exchange scenario
// -------------------------------------------
//
typedef struct _EXCHANGE_PROC_INFO
{
	HCRYPTPROV hProv;
	HCRYPTPROV hInteropProv;
	ALG_ID aiHashAlg;
	DWORD dwPublicKeySize;
	DATA_BLOB dbPlainText;
} EXCHANGE_PROC_INFO, *PEXCHANGE_PROC_INFO;

//
// Function: TestKeyExchangeProc
// Purpose: Simulate a key/data exchange scenario for the specified
// encryption alg.
//
BOOL TestKeyExchangeProc(
		PALGNODE pAlgNode,
		PTESTCASE ptc,
		PVOID pvExchangeProcInfo);

//
// ------------------
// Known Hash Vectors
// ------------------
//

// 8 bytes of test data
#define KNOWN_HASH_DATA						"HashThis"
#define KNOWN_HASH_DATALEN					8

// known result of an MD5 hash on the above buffer
static BYTE g_rgbKnownMD5[] =
{
    0xb8, 0x2f, 0x6b, 0x11, 0x31, 0xc8, 0xec, 0xf4,
    0xfe, 0x0b, 0xf0, 0x6d, 0x2a, 0xda, 0x3f, 0xc3
};

// known result of an SHA-1 hash on the above buffer
static BYTE g_rgbKnownSHA1[] =
{
    0xe8, 0x96, 0x82, 0x85, 0xeb, 0xae, 0x01, 0x14,
    0x73, 0xf9, 0x08, 0x45, 0xc0, 0x6a, 0x6d, 0x3e,
    0x69, 0x80, 0x6a, 0x0c
};

#endif