/*
Logging.c
4/23/00 dangriff created
This is the output/logging code used by the CSP Test Suite. Expect that this
set of wrappers will be modified as the Test Suite evolves.
*/
#include <windows.h>
#include <stdio.h>
#include <stdarg.h>
#include "cspstruc.h"
#include "logging.h"
#include "csptestsuite.h"
//
// Logging state variables
//
static BOOL g_fTestSuiteError = FALSE;
static BOOL g_fCSPClassError = FALSE;
static BOOL g_fTestLevelError = FALSE;
static BOOL g_fAPIError = FALSE;
static BOOL g_fCurrentAPIUnexpected = FALSE;
static DWORD g_dwCurrentCSPClass = 0;
static DWORD g_dwCurrentTestLevel = 0;
static API_NAME g_CurrentAPI;
static DWORD g_dwCurrentAPISubset = 0; // TEST_CASES_POSITIVE or TEST_CASES_NEGATIVE
// Test case set counter
static DWORD g_dwTestCaseIDMajor = 0;
//
// User-specified settings
//
//static LOG_VERBOSE g_Verbose = Terse;
static LPWSTR g_pwszProvName = NULL;
static DWORD g_dwExternalProvType = 0;
static LPWSTR g_pwszInteropProvName = NULL;
static DWORD g_dwInteropProvType = 0;
//
// Function: LogInfo
//
void LogInfo(IN LPWSTR pwszInfo)
{
ezLogMsg(LOG_INFO, NULL, NULL, __LINE__, L"%s", pwszInfo);
}
//
// Function: LogUserOption
//
void LogUserOption(IN LPWSTR pwszOption)
{
ezLogMsg(LOG_USER_OPTION, NULL, NULL, __LINE__, L"%s", pwszOption);
}
//
// Function: LogCreatingUserProtectedKey
//
void LogCreatingUserProtectedKey(void)
{
LogTestCaseSeparator(TRUE);
ezLogMsg(
LOG_USER_PROTECTED_KEY,
NULL,
NULL,
__LINE__,
L"Creating user protected key. You should see UI.");
}
//
// Function: FlagToString
//
BOOL FlagToString(
IN DWORD dwFlag,
IN FLAGTOSTRING_ITEM rgFlagToString [],
IN DWORD cFlagToString,
OUT WCHAR rgwsz [],
IN FLAG_TYPE FlagType)
{
BOOL fFound = FALSE;
unsigned iString = 0;
for (iString = 0; iString < cFlagToString; iString++)
{
if ( ((ExactMatch == FlagType) &&
(dwFlag == rgFlagToString[iString].dwKey)) ||
((Maskable == FlagType) &&
(dwFlag & rgFlagToString[iString].dwKey)))
{
if (fFound)
{
//
// One or more flags have already been found,
// so print a "|" to delimit multiple strings.
//
wsprintf(
rgwsz += wcslen(rgwsz),
L" | %s",
rgFlagToString[iString].pwszString);
}
else
{
fFound = TRUE;
wcscpy(
rgwsz,
rgFlagToString[iString].pwszString);
}
if (ExactMatch == FlagType)
{
break;
}
}
}
return fFound;
}
//
// Function: AcquireContextFlagToString
//
BOOL AcquireContextFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM AcquireContextFlagStrings [] = {
{ CRYPT_VERIFYCONTEXT, L"CRYPT_VERIFYCONTEXT" },
{ CRYPT_NEWKEYSET, L"CRYPT_NEWKEYSET" },
{ CRYPT_MACHINE_KEYSET, L"CRYPT_MACHINE_KEYSET" },
{ CRYPT_DELETEKEYSET, L"CRYPT_DELETEKEYSET" },
{ CRYPT_SILENT, L"CRYPT_SILENT" }
};
return FlagToString(
dwFlag,
AcquireContextFlagStrings,
FLAGTOSTRING_SIZE(AcquireContextFlagStrings),
rgwsz,
Maskable);
}
//
// Function: GetProvParamToString
//
BOOL GetProvParamToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM GetProvParamStrings [] = {
{ PP_CONTAINER, L"PP_CONTAINER" },
{ PP_ENUMALGS, L"PP_ENUMALGS" },
{ PP_ENUMALGS_EX, L"PP_ENUMALGS_EX" },
{ PP_ENUMCONTAINERS, L"PP_ENUMCONTAINERS" },
{ PP_IMPTYPE, L"PP_IMPTYPE" },
{ PP_NAME, L"PP_NAME" },
{ PP_VERSION, L"PP_VERSION" },
{ PP_SIG_KEYSIZE_INC, L"PP_SIG_KEYSIZE_INC" },
{ PP_KEYX_KEYSIZE_INC, L"PP_KEYX_KEYSIZE_INC" },
{ PP_KEYSET_SEC_DESCR, L"PP_KEYSET_SEC_DESCR" },
{ PP_UNIQUE_CONTAINER, L"PP_UNIQUE_CONTAINER" },
{ PP_PROVTYPE, L"PP_PROVTYPE" },
{ PP_USE_HARDWARE_RNG, L"PP_USE_HARDWARE_RNG" },
{ PP_KEYSPEC, L"PP_KEYSPEC" }
};
return FlagToString(
dwFlag,
GetProvParamStrings,
FLAGTOSTRING_SIZE(GetProvParamStrings),
rgwsz,
ExactMatch);
}
//
// Function: SetProvParamToString
//
BOOL SetProvParamToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM SetProvParamStrings [] = {
{ PP_CLIENT_HWND, L"PP_CLIENT_HWND" },
{ PP_KEYSET_SEC_DESCR, L"PP_KEYSET_SEC_DESCR" },
{ PP_USE_HARDWARE_RNG, L"PP_USE_HARDWARE_RNG" }
};
return FlagToString(
dwFlag,
SetProvParamStrings,
FLAGTOSTRING_SIZE(SetProvParamStrings),
rgwsz,
ExactMatch);
}
//
// Function: AlgidToString
//
BOOL AlgidToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM AlgidStrings [] = {
{ AT_SIGNATURE, L"AT_SIGNATURE" },
{ AT_KEYEXCHANGE, L"AT_KEYEXCHANGE" },
{ CALG_MD2, L"CALG_MD2" },
{ CALG_MD4, L"CALG_MD4" },
{ CALG_MD5, L"CALG_MD5" },
{ CALG_SHA, L"CALG_SHA" },
{ CALG_SHA1, L"CALG_SHA1" },
{ CALG_MAC, L"CALG_MAC" },
{ CALG_RSA_SIGN, L"CALG_RSA_SIGN" },
{ CALG_DSS_SIGN, L"CALG_DSS_SIGN" },
{ CALG_RSA_KEYX, L"CALG_RSA_KEYX" },
{ CALG_DES, L"CALG_DES" },
{ CALG_3DES_112, L"CALG_3DES_112" },
{ CALG_3DES, L"CALG_3DES" },
{ CALG_DESX, L"CALG_DESX" },
{ CALG_RC2, L"CALG_RC2" },
{ CALG_RC4, L"CALG_RC4" },
{ CALG_SEAL, L"CALG_SEAL" },
{ CALG_DH_SF, L"CALG_DH_SF" },
{ CALG_DH_EPHEM, L"CALG_DH_EPHEM" },
{ CALG_AGREEDKEY_ANY, L"CALG_AGREEDKEY_ANY" },
{ CALG_KEA_KEYX, L"CALG_KEA_KEYX" },
{ CALG_HUGHES_MD5, L"CALG_HUGHES_MD5" },
{ CALG_SKIPJACK, L"CALG_SKIPJACK" },
{ CALG_TEK, L"CALG_TEK" },
{ CALG_CYLINK_MEK, L"CALG_CYLINK_MEK" },
{ CALG_SSL3_SHAMD5, L"CALG_SSL3_SHAMD5" },
{ CALG_SSL3_MASTER, L"CALG_SSL3_MASTER" },
{ CALG_SCHANNEL_MASTER_HASH, L"CALG_SCHANNEL_MASTER_HASH" },
{ CALG_SCHANNEL_MAC_KEY, L"CALG_SCHANNEL_MAC_KEY" },
{ CALG_SCHANNEL_ENC_KEY, L"CALG_SCHANNEL_ENC_KEY" },
{ CALG_PCT1_MASTER, L"CALG_PCT1_MASTER" },
{ CALG_SSL2_MASTER, L"CALG_SSL2_MASTER" },
{ CALG_TLS1_MASTER, L"CALG_TLS1_MASTER" },
{ CALG_RC5, L"CALG_RC5" },
{ CALG_HMAC, L"CALG_HMAC" },
{ CALG_TLS1PRF, L"CALG_TLS1PRF" },
{ CALG_HASH_REPLACE_OWF, L"CALG_HASH_REPLACE_OWF" }
};
return FlagToString(
dwFlag,
AlgidStrings,
FLAGTOSTRING_SIZE(AlgidStrings),
rgwsz,
ExactMatch);
}
//
// Function: DeriveKeyFlagToString
//
BOOL DeriveKeyFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM DeriveKeyFlagStrings [] = {
{ CRYPT_CREATE_SALT, L"CRYPT_CREATE_SALT" },
{ CRYPT_EXPORTABLE, L"CRYPT_EXPORTABLE" },
{ CRYPT_NO_SALT, L"CRYPT_NO_SALT" },
{ CRYPT_UPDATE_KEY, L"CRYPT_UPDATE_KEY" }
};
return FlagToString(
dwFlag,
DeriveKeyFlagStrings,
FLAGTOSTRING_SIZE(DeriveKeyFlagStrings),
rgwsz,
Maskable);
}
//
// Function: EncryptFlagToString
//
BOOL EncryptFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM EncryptFlagStrings [] = {
{ CRYPT_OAEP, L"CRYPT_OAEP" }
};
return FlagToString(
dwFlag,
EncryptFlagStrings,
FLAGTOSTRING_SIZE(EncryptFlagStrings),
rgwsz,
Maskable);
}
//
// Function: ExportKeyBlobTypeToString
//
BOOL ExportKeyBlobTypeToString (
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM ExportKeyBlobTypeStrings [] = {
{ OPAQUEKEYBLOB, L"OPAQUEKEYBLOB" },
{ PRIVATEKEYBLOB, L"PRIVATEKEYBLOB" },
{ PUBLICKEYBLOB, L"PUBLICKEYBLOB" },
{ SIMPLEBLOB, L"SIMPLEBLOB" },
{ SYMMETRICWRAPKEYBLOB, L"SYMMETRICWRAPKEYBLOB" }
};
return FlagToString(
dwFlag,
ExportKeyBlobTypeStrings,
FLAGTOSTRING_SIZE(ExportKeyBlobTypeStrings),
rgwsz,
ExactMatch);
}
//
// Function: ExportKeyFlagToString
//
BOOL ExportKeyFlagToString (
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM ExportKeyFlagStrings [] = {
{ CRYPT_DESTROYKEY, L"CRYPT_DESTROYKEY" },
{ CRYPT_SSL2_FALLBACK, L"CRYPT_SSL2_FALLBACK" },
{ CRYPT_OAEP, L"CRYPT_OAEP" }
};
return FlagToString(
dwFlag,
ExportKeyFlagStrings,
FLAGTOSTRING_SIZE(ExportKeyFlagStrings),
rgwsz,
Maskable);
}
//
// Function: GenKeyFlagToString
//
BOOL GenKeyFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM GenKeyFlagStrings [] = {
{ CRYPT_CREATE_SALT, L"CRYPT_CREATE_SALT" },
{ CRYPT_EXPORTABLE, L"CRYPT_EXPORTABLE" },
{ CRYPT_NO_SALT, L"CRYPT_NO_SALT" },
{ CRYPT_PREGEN, L"CRYPT_PREGEN" },
{ CRYPT_USER_PROTECTED, L"CRYPT_USER_PROTECTED" }
};
return FlagToString(
dwFlag,
GenKeyFlagStrings,
FLAGTOSTRING_SIZE(GenKeyFlagStrings),
rgwsz,
Maskable);
}
//
// Function: HashParamToString
//
BOOL HashParamToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM HashParamStrings [] = {
{ HP_ALGID, L"HP_ALGID" },
{ HP_HASHSIZE, L"HP_HASHSIZE" },
{ HP_HASHVAL, L"HP_HASHVAL" },
{ HP_HMAC_INFO, L"HP_HMAC_INFO" }
};
return FlagToString(
dwFlag,
HashParamStrings,
FLAGTOSTRING_SIZE(HashParamStrings),
rgwsz,
ExactMatch);
}
//
// Function: KeyParamToString
//
BOOL KeyParamToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM KeyParamStrings [] = {
{ KP_ALGID, L"KP_ALGID" },
{ KP_BLOCKLEN, L"KP_BLOCKLEN" },
{ KP_KEYLEN, L"KP_KEYLEN" },
{ KP_SALT, L"KP_SALT" },
{ KP_SALT_EX, L"KP_SALT_EX" },
{ KP_PERMISSIONS, L"KP_PERMISSIONS" },
{ KP_P, L"KP_P" },
{ KP_Q, L"KP_Q" },
{ KP_G, L"KP_G" },
{ KP_X, L"KP_X" },
{ KP_EFFECTIVE_KEYLEN, L"KP_EFFECTIVE_KEYLEN" },
{ KP_IV, L"KP_IV" },
{ KP_PADDING, L"KP_PADDING" },
{ KP_MODE, L"KP_MODE" },
{ KP_MODE_BITS, L"KP_MODE_BITS" },
{ KP_PUB_PARAMS, L"KP_PUB_PARAMS" }
};
return FlagToString(
dwFlag,
KeyParamStrings,
FLAGTOSTRING_SIZE(KeyParamStrings),
rgwsz,
ExactMatch);
}
//
// Function: KeyParamModeToString
//
BOOL KeyParamModeToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM KeyParamModeStrings[] = {
{ CRYPT_MODE_CBC, L"CRYPT_MODE_CBC" },
{ CRYPT_MODE_CFB, L"CRYPT_MODE_CFB" },
{ CRYPT_MODE_ECB, L"CRYPT_MODE_ECB" },
{ CRYPT_MODE_OFB, L"CRYPT_MODE_OFB" }
};
return FlagToString(
dwFlag,
KeyParamModeStrings,
FLAGTOSTRING_SIZE(KeyParamModeStrings),
rgwsz,
ExactMatch);
}
//
// Function: KeyParamPermissionToString
//
BOOL KeyParamPermissionToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM KeyParamPermissionStrings[] = {
{ CRYPT_DECRYPT, L"CRYPT_DECRYPT" },
{ CRYPT_ENCRYPT, L"CRYPT_ENCRYPT" },
{ CRYPT_EXPORT, L"CRYPT_EXPORT" },
{ CRYPT_MAC, L"CRYPT_MAC" },
{ CRYPT_READ, L"CRYPT_READ" },
{ CRYPT_WRITE, L"CRYPT_WRITE" }
};
return FlagToString(
dwFlag,
KeyParamPermissionStrings,
FLAGTOSTRING_SIZE(KeyParamPermissionStrings),
rgwsz,
Maskable);
}
//
// Function: ProvParamEnumFlagToString
//
BOOL ProvParamEnumFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM ProvParamEnumFlagStrings[] = {
{ CRYPT_FIRST, L"CRYPT_FIRST" },
{ CRYPT_MACHINE_KEYSET, L"CRYPT_MACHINE_KEYSET" }
};
return FlagToString(
dwFlag,
ProvParamEnumFlagStrings,
FLAGTOSTRING_SIZE(ProvParamEnumFlagStrings),
rgwsz,
Maskable);
}
//
// Function: ProvParamSecDescrFlagToString
//
BOOL ProvParamSecDescrFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM ProvParamSecDescrFlagStrings[] = {
{ OWNER_SECURITY_INFORMATION, L"OWNER_SECURITY_INFORMATION" },
{ GROUP_SECURITY_INFORMATION, L"GROUP_SECURITY_INFORMATION" },
{ DACL_SECURITY_INFORMATION, L"DACL_SECURITY_INFORMATION" },
{ SACL_SECURITY_INFORMATION, L"SACL_SECURITY_INFORMATION" }
};
return FlagToString(
dwFlag,
ProvParamSecDescrFlagStrings,
FLAGTOSTRING_SIZE(ProvParamSecDescrFlagStrings),
rgwsz,
Maskable);
}
//
// Function: ProvParamImpTypeToString
//
BOOL ProvParamImpTypeToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM ProvParamImpTypeStrings[] = {
{ CRYPT_IMPL_HARDWARE, L"CRYPT_IMPL_HARDWARE" },
{ CRYPT_IMPL_SOFTWARE, L"CRYPT_IMPL_SOFTWARE" },
{ CRYPT_IMPL_MIXED, L"CRYPT_IMPL_MIXED" },
{ CRYPT_IMPL_UNKNOWN, L"CRYPT_IMPL_UNKNOWN" }
};
return FlagToString(
dwFlag,
ProvParamImpTypeStrings,
FLAGTOSTRING_SIZE(ProvParamImpTypeStrings),
rgwsz,
ExactMatch);
}
//
// Function: HashDataFlagToString
//
BOOL HashDataFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM HashDataFlagStrings[] = {
{ CRYPT_USERDATA, L"CRYPT_USERDATA" }
};
return FlagToString(
dwFlag,
HashDataFlagStrings,
FLAGTOSTRING_SIZE(HashDataFlagStrings),
rgwsz,
Maskable);
}
//
// Function: HashSessionKeyFlagToString
//
BOOL HashSessionKeyFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM HashSessionKeyFlagStrings[] = {
{ CRYPT_LITTLE_ENDIAN, L"CRYPT_LITTLE_ENDIAN" }
};
return FlagToString(
dwFlag,
HashSessionKeyFlagStrings,
FLAGTOSTRING_SIZE(HashSessionKeyFlagStrings),
rgwsz,
Maskable);
}
//
// Function: ImportKeyFlagToString
//
BOOL ImportKeyFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM ImportKeyFlagStrings[] = {
{ CRYPT_EXPORTABLE, L"CRYPT_EXPORTABLE" },
{ CRYPT_OAEP, L"CRYPT_OAEP" },
{ CRYPT_NO_SALT, L"CRYPT_NO_SALT" }
};
return FlagToString(
dwFlag,
ImportKeyFlagStrings,
FLAGTOSTRING_SIZE(ImportKeyFlagStrings),
rgwsz,
Maskable);
}
//
// Function: SignHashFlagToString
//
BOOL SignHashFlagToString(
IN DWORD dwFlag,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM SignHashFlagStrings[] = {
{ CRYPT_NOHASHOID, L"CRYPT_NOHASHOID" }
};
return FlagToString(
dwFlag,
SignHashFlagStrings,
FLAGTOSTRING_SIZE(SignHashFlagStrings),
rgwsz,
Maskable);
}
//
// Function: TestCaseTypeToString
//
BOOL TestCaseTypeToString(
IN DWORD dwTestCaseType,
OUT WCHAR rgwsz [])
{
FLAGTOSTRING_ITEM TestCaseTypeStrings[] = {
{ TEST_CASES_POSITIVE, L"Positive test cases. API's should return TRUE" },
{ TEST_CASES_NEGATIVE, L"Negative test cases. API's should return FALSE" },
{ TEST_CASES_SCENARIO, L"Scenario test cases. Tests using multiple API's" },
{ TEST_CASES_INTEROP, L"Interoperability test cases. Tests using multiple API's and two CSP's" }
};
return FlagToString(
dwTestCaseType,
TestCaseTypeStrings,
FLAGTOSTRING_SIZE(TestCaseTypeStrings),
rgwsz,
ExactMatch);
};
//
// Function:
//
BOOL ApiNameToString(
API_NAME ApiName,
OUT WCHAR rgwsz[])
{
FLAGTOSTRING_ITEM ApiNameStrings [] = {
{ API_CRYPTACQUIRECONTEXT, L"CryptAcquireContext" },
{ API_CRYPTCREATEHASH, L"CryptCreateHash" },
{ API_CRYPTDECRYPT, L"CryptDecrypt" },
{ API_CRYPTDERIVEKEY, L"CryptDeriveKey" },
{ API_CRYPTDESTROYHASH, L"CryptDestroyHash" },
{ API_CRYPTDESTROYKEY, L"CryptDestroyKey" },
{ API_CRYPTENCRYPT, L"CryptEncrypt" },
{ API_CRYPTEXPORTKEY, L"CryptExportKey" },
{ API_CRYPTGENKEY, L"CryptGenKey" },
{ API_CRYPTGENRANDOM, L"CryptGenRandom" },
{ API_CRYPTGETHASHPARAM, L"CryptGetHashParam" },
{ API_CRYPTGETKEYPARAM, L"CryptGetKeyParam" },
{ API_CRYPTGETPROVPARAM, L"CryptGetProvParam" },
{ API_CRYPTGETUSERKEY, L"CryptGetUserKey" },
{ API_CRYPTHASHDATA, L"CryptHashData" },
{ API_CRYPTHASHSESSIONKEY, L"CryptHashSessionKey" },
{ API_CRYPTIMPORTKEY, L"CryptImportKey" },
{ API_CRYPTRELEASECONTEXT, L"CryptReleaseContext" },
{ API_CRYPTSETHASHPARAM, L"CryptSetHashParam" },
{ API_CRYPTSETKEYPARAM, L"CryptSetKeyParam" },
{ API_CRYPTSETPROVPARAM, L"CryptSetProvParam" },
{ API_CRYPTSIGNHASH, L"CryptSignHash" },
{ API_CRYPTVERIFYSIGNATURE, L"CryptVerifySignature" },
{ API_CRYPTDUPLICATEHASH, L"CryptDuplicateHash" },
{ API_CRYPTDUPLICATEKEY, L"CryptDuplicateKey" },
//
// Advapi32 entry point
//
{ API_CRYPTCONTEXTADDREF, L"CryptContextAddRef" },
//
// Non-Crypto API functions
//
{ API_MEMORY, L"Memory allocation" },
{ API_DATACOMPARE, L"Data comparision (see previous API)" },
{ API_GETDESKTOPWINDOW, L"GetDesktopWindow" }
};
return FlagToString(
ApiName,
ApiNameStrings,
FLAGTOSTRING_SIZE(ApiNameStrings),
rgwsz,
ExactMatch);
}
//
// Function: LogCleanupParamInfo
//
void LogCleanupParamInfo(
IN OUT PAPI_PARAM_INFO pParamInfo,
IN DWORD cParamInfo)
{
unsigned iParam;
for (iParam = 0; iParam < cParamInfo; iParam++)
{
if (pParamInfo[iParam].pbSaved)
free(pParamInfo[iParam].pbSaved);
}
}
//
// Function: LogInitParamInfo
//
BOOL LogInitParamInfo(
IN OUT PAPI_PARAM_INFO pParamInfo,
IN DWORD cParamInfo,
IN PTESTCASE ptc)
{
unsigned iParam;
for (iParam = 0; iParam < cParamInfo; iParam++)
{
if (pParamInfo[iParam].fPrintBytes)
{
if ( NULL != pParamInfo[iParam].pbParam &&
((PBYTE) TEST_INVALID_POINTER) != pParamInfo[iParam].pbParam &&
NULL != pParamInfo[iParam].pcbBytes &&
((PDWORD) TEST_INVALID_POINTER) != pParamInfo[iParam].pcbBytes)
{
// Save bytes to a second buffer
if (! TestAlloc(
&pParamInfo[iParam].pbSaved,
*pParamInfo[iParam].pcbBytes,
ptc))
{
return FALSE;
}
memcpy(
pParamInfo[iParam].pbSaved,
pParamInfo[iParam].pbParam,
*pParamInfo[iParam].pcbBytes);
}
}
}
return TRUE;
}
//
// Function: LogParamInfo
//
void LogParamInfo(
PAPI_PARAM_INFO pParamInfo,
DWORD cParamInfo,
BOOL fLogToConsole)
{
DWORD dwLogApiParameter = LOG_API_PARAMETER;
WCHAR rgwsz [ BUFFER_LENGTH ];
unsigned iParam;
if (fLogToConsole)
{
// Feedback has been to not display parameters with the console
// output. To change this, uncomment the next line.
//dwLogApiParameter = LOG_API_PARAMETER_CONSOLE;
}
memset(rgwsz, 0, sizeof(rgwsz));
for (iParam = 0; iParam < cParamInfo; iParam++)
{
switch( pParamInfo[iParam].Type )
{
case Handle:
{
ezLogMsg(
dwLogApiParameter,
NULL,
NULL,
__LINE__,
L" %s: 0x%x",
pParamInfo[iParam].pwszName,
pParamInfo[iParam].pulParam);
break;
}
case Pointer:
{
ezLogMsg(
dwLogApiParameter,
NULL,
NULL,
__LINE__,
L" %s: 0x%x",
pParamInfo[iParam].pwszName,
pParamInfo[iParam].pbParam);
if ( pParamInfo[iParam].fPrintBytes &&
pParamInfo[iParam].pbSaved)
{
wsprintf(rgwsz, L"INPUT value", pParamInfo[iParam].pwszName);
PrintBytes(
rgwsz,
pParamInfo[iParam].pbSaved,
*pParamInfo[iParam].pcbBytes);
*rgwsz = L'\0';
}
if ( pParamInfo[iParam].fPrintBytes &&
NULL != pParamInfo[iParam].pbParam &&
(PBYTE) TEST_INVALID_POINTER != pParamInfo[iParam].pbParam &&
NULL != pParamInfo[iParam].pcbBytes &&
(PDWORD) TEST_INVALID_POINTER != pParamInfo[iParam].pcbBytes)
{
wsprintf(rgwsz, L"OUTPUT value", pParamInfo[iParam].pwszName);
PrintBytes(
rgwsz,
pParamInfo[iParam].pbParam,
*(pParamInfo[iParam].pcbBytes));
*rgwsz = L'\0';
}
break;
}
case Dword:
{
//
// If a pfnFlagToString function has been specified,
// attempt to translate the flag(s).
//
if (pParamInfo[iParam].pfnFlagToString)
{
pParamInfo[iParam].pfnFlagToString(
pParamInfo[iParam].dwParam,
rgwsz);
ezLogMsg(
dwLogApiParameter,
NULL,
NULL,
__LINE__,
L" %s: 0x%x (%s)",
pParamInfo[iParam].pwszName,
pParamInfo[iParam].dwParam,
rgwsz);
rgwsz[0] = L'\0';
}
else
{
ezLogMsg(
dwLogApiParameter,
NULL,
NULL,
__LINE__,
L" %s: 0x%x",
pParamInfo[iParam].pwszName,
pParamInfo[iParam].dwParam);
}
break;
}
case String:
{
ezLogMsg(
dwLogApiParameter,
NULL,
NULL,
__LINE__,
L" %s: %s",
pParamInfo[iParam].pwszName,
pParamInfo[iParam].pwszParam);
break;
}
case Boolean:
{
ezLogMsg(
dwLogApiParameter,
NULL,
NULL,
__LINE__,
L" %s: %s",
pParamInfo[iParam].pwszName,
pParamInfo[iParam].fParam ? STRING_TRUE : STRING_FALSE);
break;
}
}
}
}
//
// Function: IncrementErrorLevel
//
DWORD IncrementErrorLevel(DWORD dwErrorLevel)
{
int iLevel;
for (
iLevel = 0;
iLevel < (sizeof(g_rgErrorLevels) / sizeof(DWORD) - 1);
iLevel++)
{
if (dwErrorLevel == g_rgErrorLevels[iLevel])
{
return g_rgErrorLevels[iLevel + 1];
}
}
return g_rgErrorLevels[iLevel];
}
//
// Function: LogInit
//
BOOL LogInit(
IN PLOGINIT_INFO pLogInitInfo)
{
EZLOG_OPENLOG_DATA EzLogOpenData;
g_pwszProvName = pLogInitInfo->pwszCSPName;
g_dwExternalProvType = pLogInitInfo->dwCSPExternalType;
g_pwszInteropProvName = pLogInitInfo->pwszInteropCSPName;
g_dwInteropProvType = pLogInitInfo->dwInteropCSPExternalType;
//
// Initialize EZLOG
//
memset(&EzLogOpenData, 0, sizeof(EzLogOpenData));
EzLogOpenData.Version = EZLOG_OPENLOG_DATA_VERSION;
EzLogOpenData.Flags = EZLOG_OUTPUT_STDOUT | EZLOG_USE_INDENTATION |
EZLOG_REPORT_BLOCKCLOSE | EZLOG_USE_ONLY_MY_LEVELS | EZLOG_LEVELS_ARE_MASKABLE;
EzLogOpenData.LogFileName = LOGFILE;
//
// Don't output the block summary table
//
EzLogOpenData.cReportBlockThresh = EZLOG_REPORT_NO_BLOCKS;
EzLogOpenData.cLevels = sizeof(g_EzLogLevels) / sizeof(EZLOG_LEVEL_INIT_DATA);
EzLogOpenData.pLevels = g_EzLogLevels;
if (! ezOpenLogEx(&EzLogOpenData))
{
return FALSE;
}
return TRUE;
}
//
// Function: LogClose
// Purpose: Close and cleanup logging
//
BOOL LogClose(void)
{
//
// Check for a Test Suite-level error
//
if (g_fTestSuiteError)
{
ezLogMsg(
CSP_ERROR_TEST_SUITE,
NULL,
NULL,
__LINE__,
L"CSP Test Suite is ending prematurely");
}
return ezCloseLog(0);
}
//
// Function: LogBeginCSPClass
// Purpose: Log the beginning of a new class, or major group, of tests.
//
BOOL LogBeginCSPClass(DWORD dwClass)
{
LPWSTR pwsz = NULL;
switch (dwClass)
{
case CLASS_INVALID:
{
pwsz = L"CLASS_INVALID";
break;
}
case CLASS_SIG_ONLY:
{
pwsz = L"CLASS_SIG_ONLY";
break;
}
case CLASS_SIG_KEYX:
{
pwsz = L"CLASS_SIG_KEYX";
break;
}
case CLASS_FULL:
{
pwsz = L"CLASS_FULL";
break;
}
}
//
// If there has been a Test Suite-level error, don't allow
// a new CSP Class set of tests to begin.
//
if (g_fTestSuiteError)
{
return FALSE;
}
else
{
g_dwCurrentCSPClass = dwClass;
return ezStartBlock(
NULL,
NULL,
EZBLOCK_OUTCOME_INDEPENDENT /*EZBLOCK_TRACK_SUBBLOCKS*/,
CSP_PASS,
L"CSP %s", pwsz);
}
}
//
// Function: LogEndCSPClass
// Purpose: Log the completion of the current class of tests.
//
BOOL LogEndCSPClass(DWORD dwClass)
{
if (g_dwCurrentCSPClass != dwClass)
{
return FALSE;
}
//
// Clear CSP Class-level error flag
//
if (g_fCSPClassError)
{
ezLogMsg(
CSP_ERROR_CSP_CLASS,
NULL,
NULL,
__LINE__,
L"CSP Class is ending prematurely");
g_fCSPClassError = FALSE;
}
return ezFinishBlock(0);
}
//
// Function: LogBeginTestLevel
// Purpose: Log the beginning of a new level, or minor group, of tests.
//
BOOL LogBeginTestLevel(DWORD dwLevel)
{
LPWSTR pwsz = NULL;
switch (dwLevel)
{
case TEST_LEVEL_CSP:
{
pwsz = L"TEST_LEVEL_CSP";
break;
}
case TEST_LEVEL_PROV:
{
pwsz = L"TEST_LEVEL_PROV";
break;
}
case TEST_LEVEL_HASH:
{
pwsz = L"TEST_LEVEL_HASH";
break;
}
case TEST_LEVEL_KEY:
{
pwsz = L"TEST_LEVEL_KEY";
break;
}
case TEST_LEVEL_CONTAINER:
{
pwsz = L"TEST_LEVEL_CONTAINER";
break;
}
}
//
// If there has been a CSP Class-level error, don't start
// a new test level until the error has been cleared.
//
if (g_fCSPClassError)
{
return FALSE;
}
else
{
g_dwCurrentTestLevel = dwLevel;
return ezStartBlock(
NULL,
NULL,
EZBLOCK_OUTCOME_INDEPENDENT /*EZBLOCK_TRACK_SUBBLOCKS*/,
CSP_PASS,
L"%s", pwsz);
}
}
//
// Function: LogEndTestLevel
// Purpose: Log the completion of the current test level.
//
BOOL LogEndTestLevel(DWORD dwLevel)
{
if (g_dwCurrentTestLevel != dwLevel)
{
return FALSE;
}
//
// Clear Test Level error flag
//
if (g_fTestLevelError)
{
ezLogMsg(
CSP_ERROR_TEST_LEVEL,
NULL,
NULL,
__LINE__,
L"Test Level is ending prematurely");
g_fTestLevelError = FALSE;
}
return ezFinishBlock(0);
}
//
// Function: LogBeginAPI
// Purpose: Log the beginning of a set of API test cases
//
BOOL LogBeginAPI(API_NAME ApiName, DWORD dwAPISubset)
{
WCHAR rgwsz[BUFFER_SIZE];
//
// If there has been a Test Level error, don't start a new
// API set until the error has been cleared.
//
if (g_fTestLevelError)
{
return FALSE;
}
else
{
g_dwTestCaseIDMajor++;
g_CurrentAPI = ApiName;
g_dwCurrentAPISubset = dwAPISubset;
ApiNameToString(ApiName, rgwsz);
wcscpy(rgwsz + wcslen(rgwsz), L", ");
TestCaseTypeToString(
dwAPISubset,
rgwsz + wcslen(rgwsz));
return ezStartBlock(
NULL,
NULL,
EZBLOCK_OUTCOME_INDEPENDENT /*EZBLOCK_TRACK_SUBBLOCKS*/,
CSP_PASS,
L"API %s",
rgwsz);
}
}
//
// Function: LogEndAPI
// Purpose: Log the completion of a set of API test cases
//
BOOL LogEndAPI(API_NAME ApiName, DWORD dwAPISubset)
{
if ( (g_CurrentAPI != ApiName) ||
(g_dwCurrentAPISubset != dwAPISubset))
{
return FALSE;
}
//
// Clear API-level error flag
//
g_fAPIError = FALSE;
return ezFinishBlock(0);
}
//
// Function: LogPass
// Purpose: Log a successful test case
//
BOOL LogPass(DWORD dwTestCaseID)
{
return ezLogMsg(
CSP_PASS,
NULL,
NULL,
__LINE__,
L"Test case %d.%d: PASS",
g_dwTestCaseIDMajor,
dwTestCaseID);
}
//
// Function: LogBeginScenarioTest
// Purpose: Log the beginning of a Scenario Test.
//
BOOL LogBeginScenarioTest(LPWSTR pwszDescription)
{
g_dwTestCaseIDMajor++;
return ezStartBlock(
NULL,
NULL,
EZBLOCK_OUTCOME_INDEPENDENT,
CSP_PASS,
L"Scenario test case - %s",
pwszDescription);
}
//
// Function: LogEndScenarioTest
// Purpose: Log the end of a Scenario Test
//
BOOL LogEndScenarioTest(void)
{
//
// Clear API-level error flag
//
g_fAPIError = FALSE;
return ezFinishBlock(0);
}
//
// Function: LogBeginInteropTest
// Purpose: Log the beginning of an Interoperability Test.
//
BOOL LogBeginInteropTest(LPWSTR pwszDescription)
{
g_dwTestCaseIDMajor++;
return ezStartBlock(
NULL,
NULL,
EZBLOCK_OUTCOME_INDEPENDENT,
CSP_PASS,
L"Interoperability test case - %s",
pwszDescription);
}
//
// Function: LogEndInteropTest
// Purpose: Log the end of an Interoperability Test
//
BOOL LogEndInteropTest(void)
{
//
// Clear API-level error flag
//
g_fAPIError = FALSE;
return ezFinishBlock(0);
}
//
// Function: DoError
// Purpose: Perform the operations for handling a test case error
//
BOOL DoError(DWORD dwTestCaseID, DWORD dwReportedErrorLevel)
{
LPWSTR pwszErrorLevel = NULL;
DWORD dwErrorLevel = dwReportedErrorLevel & (CSP_ERROR_CONTINUE | CSP_ERROR_API);
switch (dwErrorLevel)
{
case CSP_ERROR_CONTINUE:
pwszErrorLevel = L"ERROR_CONTINUE";
break;
case CSP_ERROR_API:
pwszErrorLevel = L"ERROR_API";
break;
}
//
// The dwErrorLevel is being masked to limit the scope of the
// error being reported at this point. If a test case fails,
// only ERROR_CONTINUE and ERROR_API (and ERROR_WARNING) errors
// will be reported. If a more severe error has been flagged,
// it will be reported when the appropriate Test Level or CSP Class
// block ends.
//
return ezLogMsg(
dwErrorLevel,
NULL,
NULL,
__LINE__,
L"Test case %d.%d: %s",
g_dwTestCaseIDMajor,
dwTestCaseID,
pwszErrorLevel);
}
//
// Function: DoWarning
// Purpose: Perform the operations for handling a test case warning
//
BOOL DoWarning(DWORD dwTestCaseID)
{
return ezLogMsg(
CSP_ERROR_WARNING,
NULL,
NULL,
__LINE__,
L"Test case %d.%d: WARNING",
g_dwTestCaseIDMajor,
dwTestCaseID);
}
//
// Function: LogTestCaseSeparator
//
BOOL LogTestCaseSeparator(BOOL fLogToConsole)
{
if (fLogToConsole)
{
return ezLogMsg(
LOG_SEPARATOR_CONSOLE,
NULL,
NULL,
__LINE__,
TEST_CASE_SEPARATOR);
}
else
{
return ezLogMsg(
LOG_SEPARATOR,
NULL,
NULL,
__LINE__,
TEST_CASE_SEPARATOR);
}
}
//
// Function: LogTestCase
//
BOOL LogTestCase(PLOGTESTCASEINFO pLogTestCaseInfo)
{
BOOL fReturn = TRUE;
DWORD dwActualErrorLevel = pLogTestCaseInfo->dwErrorLevel;
//LPWSTR pwszExpected = NULL;
//LPWSTR pwszActual = NULL;
LPWSTR pwsz = NULL;
BOOL fLogToConsole = FALSE;
DWORD dwLogApiName = LOG_API_NAME;
DWORD dwLogInfo = LOG_INFO;
WCHAR rgwsz[BUFFER_SIZE];
if (pLogTestCaseInfo->fPass)
{
LogTestCaseSeparator(FALSE);
LogPass(pLogTestCaseInfo->dwTestCaseID);
goto Return;
}
if (KNOWN_ERROR_UNKNOWN != pLogTestCaseInfo->KnownErrorID)
{
dwActualErrorLevel = GetKnownErrorValue(
pLogTestCaseInfo->KnownErrorID,
dwActualErrorLevel);
}
if (dwActualErrorLevel & CSP_ERROR_WARNING)
{
//
// Don't look for other error flags if a warning has been flagged,
// just handle the warning and return.
//
//fLogToConsole = TRUE;
LogTestCaseSeparator(fLogToConsole);
DoWarning(pLogTestCaseInfo->dwTestCaseID);
goto Return;
}
if (dwActualErrorLevel &
(CSP_ERROR_CONTINUE | CSP_ERROR_API |
CSP_ERROR_TEST_LEVEL | CSP_ERROR_CSP_CLASS |
CSP_ERROR_TEST_SUITE))
{
fLogToConsole = TRUE;
LogTestCaseSeparator(fLogToConsole);
DoError(pLogTestCaseInfo->dwTestCaseID, dwActualErrorLevel);
}
if (dwActualErrorLevel & CSP_ERROR_API)
{
g_fAPIError = TRUE;
fReturn = FALSE;
}
if (dwActualErrorLevel & CSP_ERROR_TEST_LEVEL)
{
g_fTestLevelError = TRUE;
}
if (dwActualErrorLevel & CSP_ERROR_CSP_CLASS)
{
g_fCSPClassError = TRUE;
}
if (dwActualErrorLevel & CSP_ERROR_TEST_SUITE)
{
g_fTestSuiteError = TRUE;
}
Return:
if (fLogToConsole)
{
dwLogApiName = LOG_API_NAME_CONSOLE;
dwLogInfo = LOG_INFO_CONSOLE;
}
ApiNameToString(pLogTestCaseInfo->ApiName, rgwsz);
ezLogMsg(
dwLogApiName,
NULL,
NULL,
__LINE__,
L"%s", rgwsz);
ezLogMsg(
dwLogInfo,
NULL,
NULL,
__LINE__,
L"Returned: %s",
pLogTestCaseInfo->fReturnVal ? STRING_TRUE : STRING_FALSE);
if (! pLogTestCaseInfo->fPass)
{
switch (pLogTestCaseInfo->dwErrorType)
{
case ERROR_API_SUCCEEDED:
pwsz = L"API succeeded unexpectedly";
break;
case ERROR_API_FAILED:
pwsz = L"API failed unexpectedly";
break;
case ERROR_WRONG_ERROR_CODE:
pwsz = L"API returned an incorrect error code";
break;
case ERROR_WIN32_FAILURE:
pwsz = L"A WIN32 (non-CSP) API failed";
break;
case ERROR_WRONG_SIZE:
pwsz = L"The API returned an incorrect data size";
break;
case ERROR_BAD_DATA:
pwsz = L"The API returned bad data";
break;
case ERROR_LIST_TOO_SHORT:
pwsz = L"The list of algorithms is too short";
break;
case ERROR_REQUIRED_ALG:
pwsz = L"A required algorithm is missing";
break;
}
ezLogMsg(
dwLogInfo,
NULL,
NULL,
__LINE__,
L"Error type: %s", pwsz);
//
// Display details about the known error status here,
// after the Error/Warning has been processed above.
//
ezLogMsg(
dwLogInfo,
NULL,
NULL,
__LINE__,
L"Known error: %s",
(KNOWN_ERROR_UNKNOWN == pLogTestCaseInfo->KnownErrorID) ? L"No" : L"Yes");
if (ERROR_WRONG_ERROR_CODE == pLogTestCaseInfo->dwErrorType)
{
FormatMessage(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_MAX_WIDTH_MASK,
NULL,
pLogTestCaseInfo->dwExpectedErrorCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
rgwsz,
BUFFER_SIZE,
NULL);
ezLogMsg(
dwLogInfo,
NULL,
NULL,
__LINE__,
L"Expected error code: 0x%x (%s)",
pLogTestCaseInfo->dwExpectedErrorCode,
rgwsz);
*rgwsz = L'\0';
}
if ( FALSE == pLogTestCaseInfo->fReturnVal ||
ERROR_API_FAILED == pLogTestCaseInfo->dwErrorType ||
ERROR_WRONG_ERROR_CODE == pLogTestCaseInfo->dwErrorType ||
ERROR_WIN32_FAILURE == pLogTestCaseInfo->dwErrorType)
{
// Don't get the error string if the error code is 0
*rgwsz = L'\0';
if (0 != pLogTestCaseInfo->dwWinError)
{
FormatMessage(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_MAX_WIDTH_MASK,
NULL,
pLogTestCaseInfo->dwWinError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
rgwsz,
BUFFER_SIZE,
NULL);
}
ezLogMsg(
dwLogInfo,
NULL,
NULL,
__LINE__,
L"Actual error code: 0x%x (%s)",
pLogTestCaseInfo->dwWinError,
rgwsz);
*rgwsz = L'\0';
}
//
// Log details about this failure
//
if (NULL != pLogTestCaseInfo->pwszErrorHelp)
{
ezLogMsg(
dwLogInfo,
NULL,
NULL,
__LINE__,
L"Test case description: %s",
pLogTestCaseInfo->pwszErrorHelp);
}
}
LogParamInfo(
pLogTestCaseInfo->pParamInfo,
pLogTestCaseInfo->cParamInfo,
fLogToConsole);
return fReturn;
}
//
// Function: LogGetInteropProvType
//
DWORD LogGetInteropProvType(void)
{
return g_dwInteropProvType;
}
//
// Function: LogGetInteropProvName
//
LPWSTR LogGetInteropProvName(void)
{
return g_pwszInteropProvName;
}
//
// Function: LogGetProvType
// Purpose: Return the provider type for which the CSP under
// test is registered (in the system registry).
//
DWORD LogGetProvType(void)
{
return g_dwExternalProvType;
}
//
// Function: LogGetProvName
// Purpose: Return the provider name for which the CSP under
// test is registered (in the system registry).
//
LPWSTR LogGetProvName(void)
{
return g_pwszProvName;
}
//
// Function: LogApiFailure
//
BOOL LogApiFailure(
IN API_NAME ApiName,
IN DWORD dwErrorType,
IN OUT PTESTCASE ptc)
{
LOGTESTCASEINFO LogTestCaseInfo;
InitLogTestCaseInfo(ptc, &LogTestCaseInfo);
LogTestCaseInfo.ApiName = ApiName;
LogTestCaseInfo.dwErrorType = dwErrorType;
LogTestCaseInfo.fPass = FALSE;
return LogTestCase(&LogTestCaseInfo);
}
//
// Function: CheckAndLogStatus
//
BOOL CheckAndLogStatus(
IN API_NAME ApiName,
IN BOOL fCallSucceeded,
IN OUT PTESTCASE ptc,
IN PAPI_PARAM_INFO pParamInfo,
IN DWORD cParamInfo)
{
DWORD dwWinError = 0;
//DWORD dwTestCaseID = 0;
LOGTESTCASEINFO LogTestCaseInfo;
InitLogTestCaseInfo(ptc, &LogTestCaseInfo);
LogTestCaseInfo.fReturnVal = fCallSucceeded;
if (! fCallSucceeded)
{
dwWinError = GetLastError();
if (ptc->fExpectSuccess)
{
//
// Test was expected to succeed, but it failed
//
LogTestCaseInfo.dwErrorType = ERROR_API_FAILED;
LogTestCaseInfo.dwWinError = dwWinError;
}
else
{
if (dwWinError != ptc->dwErrorCode)
{
//
// Test failed as expected, but returned the wrong
// error code.
//
LogTestCaseInfo.dwWinError = dwWinError;
LogTestCaseInfo.dwErrorType = ERROR_WRONG_ERROR_CODE;
}
//
// Otherwise, the test failed as expected, and it
// returned the correct error code.
//
else
{
LogTestCaseInfo.fPass = TRUE;
}
}
}
else
{
if (! ptc->fExpectSuccess)
{
//
// The test was expected to fail, but it succeeded.
//
LogTestCaseInfo.dwErrorType = ERROR_API_SUCCEEDED;
}
//
// Otherwise, the test succeeded as expected.
//
else
{
LogTestCaseInfo.fPass = TRUE;
}
}
//
// Now dwErrorType will be non-zero in any of three cases:
// 1) The API should have succeeded, but failed
// 2) The API should have failed, but succeeded
// 3) The API failed as expected, but returned the wrong error code
//
if (0 != LogTestCaseInfo.dwErrorType)
{
LogTestCaseInfo.dwErrorLevel = ptc->dwErrorLevel;
LogTestCaseInfo.dwExpectedErrorCode = ptc->dwErrorCode;
//
// The Microsoft RSA CSP's in Win2K do not return
// ERROR_INVALID_HANDLE for most, if not all, of the test cases
// involving that error code in this test suite. Therefore,
// intercept those error here, and flag them as known for that
// platform.
//
if ( (ERROR_WRONG_ERROR_CODE == LogTestCaseInfo.dwErrorType) &&
(ERROR_INVALID_HANDLE == LogTestCaseInfo.dwExpectedErrorCode))
{
LogTestCaseInfo.KnownErrorID = KNOWN_ERRORINVALIDHANDLE;
}
//
// The Microsoft RSA CSP's in Win2K do not return
// NTE_BAD_KEY for the negative test cases involving that
// error code. Intercept those errors here and flag them as
// known for that platform.
//
if ( (ERROR_WRONG_ERROR_CODE == LogTestCaseInfo.dwErrorType) &&
(NTE_BAD_KEY == LogTestCaseInfo.dwExpectedErrorCode))
{
LogTestCaseInfo.KnownErrorID = KNOWN_NTEBADKEY;
}
//
// The Microsoft RSA CSP's in Win2K do not return NTE_BAD_HASH
// for the negative test cases involving that error code. Intercept
// those errors here and flag them as known for that platform.
//
if ( (ERROR_WRONG_ERROR_CODE == LogTestCaseInfo.dwErrorType) &&
(NTE_BAD_HASH == LogTestCaseInfo.dwExpectedErrorCode))
{
LogTestCaseInfo.KnownErrorID = KNOWN_NTEBADHASH;
}
}
// Finally, increment the current test case ID
++ptc->dwTestCaseID;
LogTestCaseInfo.dwTestCaseID = ptc->dwTestCaseID;
LogTestCaseInfo.pParamInfo = pParamInfo;
LogTestCaseInfo.cParamInfo = cParamInfo;
LogTestCaseInfo.ApiName = ApiName;
return LogTestCase(&LogTestCaseInfo);
}
//
// Function: InitFailInfo
//
void InitLogTestCaseInfo(
IN PTESTCASE ptc,
OUT PLOGTESTCASEINFO pLogTestCaseInfo)
{
memset(pLogTestCaseInfo, 0, sizeof(LOGTESTCASEINFO));
pLogTestCaseInfo->dwErrorLevel = ptc->dwErrorLevel;
pLogTestCaseInfo->dwExpectedErrorCode = ptc->dwErrorCode;
pLogTestCaseInfo->dwTestCaseID = ptc->dwTestCaseID;
pLogTestCaseInfo->KnownErrorID = ptc->KnownErrorID;
pLogTestCaseInfo->pwszErrorHelp = ptc->pwszErrorHelp;
}
//
// Function: LogBadParam
//
BOOL LogBadParam(
API_NAME ApiName,
LPWSTR pwszErrorHelp,
PTESTCASE ptc)
{
LOGTESTCASEINFO LogTestCaseInfo;
++ptc->dwTestCaseID;
InitLogTestCaseInfo(ptc, &LogTestCaseInfo);
LogTestCaseInfo.ApiName = ApiName;
LogTestCaseInfo.dwErrorType = ERROR_BAD_DATA;
LogTestCaseInfo.pwszErrorHelp = pwszErrorHelp;
LogTestCaseInfo.fPass = FALSE;
return LogTestCase(&LogTestCaseInfo);
}
//
// Function: LogProvEnumalgsEx
//
void LogProvEnumalgsEx(PROV_ENUMALGS_EX *pData)
{
LPWSTR pwszAlgType = NULL;
LPWSTR pwszName = MkWStr(pData->szName);
LPWSTR pwszLongName = MkWStr(pData->szLongName);
// Determine the algorithm type.
switch(GET_ALG_CLASS(pData->aiAlgid))
{
case ALG_CLASS_DATA_ENCRYPT: pwszAlgType = L"Encrypt ";
break;
case ALG_CLASS_HASH: pwszAlgType = L"Hash ";
break;
case ALG_CLASS_KEY_EXCHANGE: pwszAlgType = L"Exchange ";
break;
case ALG_CLASS_SIGNATURE: pwszAlgType = L"Signature";
break;
default: pwszAlgType = L"Unknown ";
}
// Print information about the algorithm.
ezLogMsg(
LOG_INFO,
NULL,
NULL,
__LINE__,
L"Algid:%8.8xh, Bits:%-4d, %-4d - %-4d, Type:%s",
pData->aiAlgid,
pData->dwDefaultLen,
pData->dwMinLen,
pData->dwMaxLen,
pwszAlgType);
ezLogMsg(
LOG_INFO,
NULL,
NULL,
__LINE__,
L" Name: %s LongName: %s Protocols: 0x%x",
pwszName,
pwszLongName,
pData->dwProtocols);
free(pwszName);
free(pwszLongName);
}
//
// Function: LogProvEnumalgs
// Purpose: Log the contents of a PROV_ENUMALGS struct
//
void LogProvEnumalgs(PROV_ENUMALGS *pData)
{
LPWSTR pwszAlgType = NULL;
LPWSTR pwszName = MkWStr(pData->szName);
// Determine the algorithm type.
switch(GET_ALG_CLASS(pData->aiAlgid))
{
case ALG_CLASS_DATA_ENCRYPT: pwszAlgType = L"Encrypt ";
break;
case ALG_CLASS_HASH: pwszAlgType = L"Hash ";
break;
case ALG_CLASS_KEY_EXCHANGE: pwszAlgType = L"Exchange ";
break;
case ALG_CLASS_SIGNATURE: pwszAlgType = L"Signature";
break;
default: pwszAlgType = L"Unknown ";
}
// Print information about the algorithm.
ezLogMsg(
LOG_INFO,
NULL,
NULL,
__LINE__,
L"Algid:%8.8xh, Bits:%-4d, Type:%s, NameLen:%-2d, Name:%s",
pData->aiAlgid,
pData->dwBitLen,
pwszAlgType,
pData->dwNameLen,
pwszName);
free(pwszName);
}