1871 lines
39 KiB
C
1871 lines
39 KiB
C
/*
|
|
|
|
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);
|
|
} |