morgan/FreeRDP
1
0
Fork 0
mirror of https://github.com/morgan9e/FreeRDP synced 2026-04-14 08:24:16 +09:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #10937 from akallabeth/x11-fix

Browse Source 
bcrypt fix
This commit is contained in:
David Fort
2024-12-09 14:18:22 +01:00
committed by GitHub
parent 045ce22aa3 77de3738b7
commit 3dcbbedb59
5 changed files with 210 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libfreerdp/locale/test/TestLocaleKeyboard.c
View File

@@ -267,7 +267,7 @@ static BOOL test_scancode_cnv(void)
(void)fprintf(stderr,
"[%" PRIu32 "]: keycode->scancode->keycode failed: %" PRIu32
" -> %" PRIu32 " -> %" PRIu32 "\n",
x, sc, kk);
x, sc, ex, kk);
return FALSE;
}
}

282
winpr/include/winpr/bcrypt.h
View File

@@ -33,238 +33,66 @@ typedef PVOID BCRYPT_KEY_HANDLE;
typedef PVOID BCRYPT_HASH_HANDLE;
typedef PVOID BCRYPT_SECRET_HANDLE;
#define BCRYPT_RSA_ALGORITHM \
(const WCHAR*)"R\x00S\x00" \
"A\x00\x00"
#define BCRYPT_RSA_SIGN_ALGORITHM \
(const WCHAR*)"R\x00S\x00" \
"A\x00_\x00S\x00I\x00G\x00N\x00\x00"
#define BCRYPT_DH_ALGORITHM (const WCHAR*)"D\x00H\x00\x00"
#define BCRYPT_DSA_ALGORITHM \
(const WCHAR*)"D\x00S\x00" \
"A\x00\x00"
#define BCRYPT_RC2_ALGORITHM \
(const WCHAR*)"R\x00" \
"C\x002\x00\x00"
#define BCRYPT_RC4_ALGORITHM \
(const WCHAR*)"R\x00" \
"C\x004\x00\x00"
#define BCRYPT_AES_ALGORITHM \
(const WCHAR*)"A\x00" \
"E\x00S\x00\x00"
#define BCRYPT_DES_ALGORITHM \
(const WCHAR*)"D\x00" \
"E\x00S\x00\x00"
#define BCRYPT_DESX_ALGORITHM \
(const WCHAR*)"D\x00" \
"E\x00S\x00X\x00\x00"
#define BCRYPT_3DES_ALGORITHM \
(const WCHAR*)"3\x00" \
"D\x00" \
"E\x00S\x00\x00"
#define BCRYPT_3DES_112_ALGORITHM \
(const WCHAR*)"3\x00" \
"D\x00" \
"E\x00S\x00_\x001\x001\x002\x00\x00"
#define BCRYPT_MD2_ALGORITHM \
(const WCHAR*)"M\x00" \
"D\x002\x00\x00"
#define BCRYPT_MD4_ALGORITHM \
(const WCHAR*)"M\x00" \
"D\x004\x00\x00"
#define BCRYPT_MD5_ALGORITHM \
(const WCHAR*)"M\x00" \
"D\x005\x00\x00"
#define BCRYPT_SHA1_ALGORITHM \
(const WCHAR*)"S\x00H\x00" \
"A\x001\x00\x00"
#define BCRYPT_SHA256_ALGORITHM \
(const WCHAR*)"S\x00H\x00" \
"A\x002\x005\x006\x00\x00"
#define BCRYPT_SHA384_ALGORITHM \
(const WCHAR*)"S\x00H\x00" \
"A\x003\x008\x004\x00\x00"
#define BCRYPT_SHA512_ALGORITHM \
(const WCHAR*)"S\x00H\x00" \
"A\x005\x001\x002\x00\x00"
#define BCRYPT_AES_GMAC_ALGORITHM \
(const WCHAR*)"A\x00" \
"E\x00S\x00-\x00G\x00M\x00" \
"A\x00" \
"C\x00\x00"
#define BCRYPT_ECDSA_ALGORITHM \
(const WCHAR*)"E\x00" \
"C\x00" \
"D\x00S\x00" \
"A\x00\x00"
#define BCRYPT_ECDSA_P256_ALGORITHM \
(const WCHAR*)"E\x00" \
"C\x00" \
"D\x00S\x00" \
"A\x00_\x00P\x002\x005\x006\x00\x00"
#define BCRYPT_ECDSA_P384_ALGORITHM \
(const WCHAR*)"E\x00" \
"C\x00" \
"D\x00S\x00" \
"A\x00_\x00P\x003\x008\x004\x00\x00"
#define BCRYPT_ECDSA_P521_ALGORITHM \
(const WCHAR*)"E\x00" \
"C\x00" \
"D\x00S\x00" \
"A\x00_\x00P\x005\x002\x001\x00\x00"
#define BCRYPT_ECDH_P256_ALGORITHM \
(const WCHAR*)"E\x00" \
"C\x00" \
"D\x00S\x00" \
"A\x00_\x00P\x002\x005\x006\x00\x00"
#define BCRYPT_ECDH_P384_ALGORITHM \
(const WCHAR*)"E\x00" \
"C\x00" \
"D\x00S\x00" \
"A\x00_\x00P\x003\x008\x004\x00\x00"
#define BCRYPT_ECDH_P521_ALGORITHM \
(const WCHAR*)"E\x00" \
"C\x00" \
"D\x00S\x00" \
"A\x00_\x00P\x005\x002\x001\x00\x00"
#define BCRYPT_RNG_ALGORITHM (const WCHAR*)"R\x00N\x00G\x00\x00"
#define BCRYPT_RNG_FIPS186_DSA_ALGORITHM \
(const WCHAR*)"F\x00I\x00P\x00S\x001\x008\x006\x00" \
"D\x00S\x00" \
"A\x00R\x00N\x00G\x00\x00"
#define BCRYPT_RNG_DUAL_EC_ALGORITHM \
(const WCHAR*)"D\x00U\x00" \
"A\x00L\x00" \
"E\x00R\x00N\x00G\x00\x00"
#define BCRYPT_RSA_ALGORITHM u"RSA"
#define BCRYPT_RSA_SIGN_ALGORITHM u"RSA_SIGN"
#define BCRYPT_DH_ALGORITHM u"DH"
#define BCRYPT_DSA_ALGORITHM u"DSA"
#define BCRYPT_RC2_ALGORITHM u"RC2"
#define BCRYPT_RC4_ALGORITHM u"RC4"
#define BCRYPT_AES_ALGORITHM u"AES"
#define BCRYPT_DES_ALGORITHM u"DES"
#define BCRYPT_DESX_ALGORITHM u"DESX"
#define BCRYPT_3DES_ALGORITHM u"3DES"
#define BCRYPT_3DES_112_ALGORITHM u"3DES_112"
#define BCRYPT_MD2_ALGORITHM u"MD2"
#define BCRYPT_MD4_ALGORITHM u"MD4"
#define BCRYPT_MD5_ALGORITHM u"MD5"
#define BCRYPT_SHA1_ALGORITHM u"SHA1"
#define BCRYPT_SHA256_ALGORITHM u"SHA256"
#define BCRYPT_SHA384_ALGORITHM u"SHA384"
#define BCRYPT_SHA512_ALGORITHM u"SHA512"
#define BCRYPT_AES_GMAC_ALGORITHM u"AES-GMAC"
#define BCRYPT_AES_CMAC_ALGORITHM u"AES-CMAC"
#define BCRYPT_ECDSA_P256_ALGORITHM u"ECDSA_P256"
#define BCRYPT_ECDSA_P384_ALGORITHM u"ECDSA_P384"
#define BCRYPT_ECDSA_P521_ALGORITHM u"ECDSA_P521"
#define BCRYPT_ECDH_P256_ALGORITHM u"ECDSA_P256"
#define BCRYPT_ECDH_P384_ALGORITHM u"ECDSA_P384"
#define BCRYPT_ECDH_P521_ALGORITHM u"ECDSA_P521"
#define BCRYPT_RNG_ALGORITHM u"RNG"
#define BCRYPT_RNG_FIPS186_DSA_ALGORITHM u"FIPS186DSARNG"
#define BCRYPT_RNG_DUAL_EC_ALGORITHM u"DUALECRNG"
#define MS_PRIMITIVE_PROVIDER \
(const WCHAR*)"M\x00i\x00" \
"c\x00r\x00o\x00s\x00o\x00" \
"f\x00t\x00 " \
"\x00P\x00r\x00i\x00m\x00i\x00t\x00i\x00v\x00" \
"e\x00 " \
"\x00P\x00r\x00o\x00v\x00i\x00" \
"d\x00" \
"e\x00r\x00\x00"
#define BCRYPT_ECDSA_ALGORITHM u"ECDSA"
#define BCRYPT_ECDH_ALGORITHM u"ECDH"
#define BCRYPT_XTS_AES_ALGORITHM u"XTS-AES"
#define MS_PRIMITIVE_PROVIDER u"Microsoft Primitive Provider"
#define MS_PLATFORM_CRYPTO_PROVIDER u"Microsoft Platform Crypto Provider"
#define BCRYPT_ALG_HANDLE_HMAC_FLAG 0x00000008
#define BCRYPT_PROV_DISPATCH 0x00000001
#define BCRYPT_OBJECT_LENGTH \
(const WCHAR*)"O\x00" \
"b\x00j\x00" \
"e\x00" \
"c\x00t\x00L\x00" \
"e\x00n\x00g\x00t\x00h\x00\x00"
#define BCRYPT_ALGORITHM_NAME \
(const WCHAR*)"A\x00l\x00g\x00o\x00r\x00i\x00t\x00h\x00m\x00N\x00" \
"a\x00m\x00" \
"e\x00\x00"
#define BCRYPT_PROVIDER_HANDLE \
(const WCHAR*)"P\x00r\x00o\x00v\x00i\x00" \
"d\x00" \
"e\x00r\x00H\x00" \
"a\x00n\x00" \
"d\x00l\x00" \
"e\x00\x00"
#define BCRYPT_CHAINING_MODE \
(const WCHAR*)"C\x00h\x00" \
"a\x00i\x00n\x00i\x00n\x00g\x00M\x00o\x00" \
"d\x00" \
"e\x00\x00"
#define BCRYPT_BLOCK_LENGTH \
(const WCHAR*)"B\x00l\x00o\x00" \
"c\x00k\x00L\x00" \
"e\x00n\x00g\x00t\x00h\x00\x00"
#define BCRYPT_KEY_LENGTH \
(const WCHAR*)"K\x00" \
"e\x00y\x00L\x00" \
"e\x00n\x00g\x00t\x00h\x00\x00"
#define BCRYPT_KEY_OBJECT_LENGTH \
(const WCHAR*)"K\x00" \
"e\x00y\x00O\x00" \
"b\x00j\x00" \
"e\x00" \
"c\x00t\x00L\x00" \
"e\x00n\x00g\x00t\x00h\x00" \
"\x00"
#define BCRYPT_KEY_STRENGTH \
(const WCHAR*)"K\x00" \
"e\x00y\x00S\x00t\x00r\x00" \
"e\x00n\x00g\x00t\x00h\x00\x00"
#define BCRYPT_KEY_LENGTHS \
(const WCHAR*)"K\x00" \
"e\x00y\x00L\x00" \
"e\x00n\x00g\x00t\x00h\x00s\x00\x00"
#define BCRYPT_BLOCK_SIZE_LIST \
(const WCHAR*)"B\x00l\x00o\x00" \
"c\x00k\x00S\x00i\x00z\x00" \
"e\x00L\x00i\x00s\x00t\x00\x00"
#define BCRYPT_EFFECTIVE_KEY_LENGTH \
(const WCHAR*)"E\x00" \
"f\x00" \
"f\x00" \
"e\x00" \
"c\x00t\x00i\x00v\x00" \
"e\x00K\x00" \
"e\x00y\x00L\x00" \
"e\x00n\x00g" \
"\x00t\x00h\x00\x00"
#define BCRYPT_HASH_LENGTH \
(const WCHAR*)"H\x00" \
"a\x00s\x00h\x00" \
"D\x00i\x00g\x00" \
"e\x00s\x00t\x00L\x00" \
"e\x00n\x00g\x00t\x00h" \
"\x00\x00"
#define BCRYPT_HASH_OID_LIST \
(const WCHAR*)"H\x00" \
"a\x00s\x00h\x00O\x00I\x00" \
"D\x00L\x00i\x00s\x00t\x00\x00"
#define BCRYPT_PADDING_SCHEMES \
(const WCHAR*)"P\x00" \
"a\x00" \
"d\x00" \
"d\x00i\x00n\x00g\x00S\x00" \
"c\x00h\x00" \
"e\x00m\x00" \
"e\x00s\x00\x00"
#define BCRYPT_SIGNATURE_LENGTH \
(const WCHAR*)"S\x00i\x00g\x00n\x00" \
"a\x00t\x00u\x00r\x00" \
"e\x00L\x00" \
"e\x00n\x00g\x00t\x00h\x00" \
"\x00"
#define BCRYPT_HASH_BLOCK_LENGTH \
(const WCHAR*)"H\x00" \
"a\x00s\x00h\x00" \
"B\x00l\x00o\x00" \
"c\x00k\x00L\x00" \
"e\x00n\x00g\x00t\x00h\x00" \
"\x00"
#define BCRYPT_AUTH_TAG_LENGTH \
(const WCHAR*)"A\x00u\x00t\x00h\x00T\x00" \
"a\x00g\x00L\x00" \
"e\x00n\x00g\x00t\x00h\x00\x00"
#define BCRYPT_PRIMITIVE_TYPE \
(const WCHAR*)"P\x00r\x00i\x00m\x00i\x00t\x00i\x00v\x00" \
"e\x00T\x00y\x00p\x00" \
"e\x00\x00"
#define BCRYPT_IS_KEYED_HASH \
(const WCHAR*)"I\x00s\x00K\x00" \
"e\x00y\x00" \
"e\x00" \
"d\x00H\x00" \
"a\x00s\x00h\x00\x00"
#define BCRYPT_KEY_DATA_BLOB \
(const WCHAR*)"K\x00" \
"e\x00y\x00" \
"D\x00" \
"a\x00t\x00" \
"a\x00" \
"B\x00l\x00o\x00" \
"b\x00\x00"
#define BCRYPT_OBJECT_LENGTH u"ObjectLength"
#define BCRYPT_ALGORITHM_NAME u"AlgorithmName"
#define BCRYPT_PROVIDER_HANDLE u"ProviderHandle"
#define BCRYPT_CHAINING_MODE u"ChainingMode"
#define BCRYPT_BLOCK_LENGTH u"BlockLength"
#define BCRYPT_KEY_LENGTH u"KeyLength"
#define BCRYPT_KEY_OBJECT_LENGTH u"KeyObjectLength"
#define BCRYPT_KEY_STRENGTH u"KeyStrength"
#define BCRYPT_KEY_LENGTHS u"KeyLengths"
#define BCRYPT_BLOCK_SIZE_LIST u"BlockSizeList"
#define BCRYPT_EFFECTIVE_KEY_LENGTH u"EffectiveKeyLength"
#define BCRYPT_HASH_LENGTH u"HashDigestLength"
#define BCRYPT_HASH_OID_LIST u"HashOIDList"
#define BCRYPT_PADDING_SCHEMES u"PaddingSchemes"
#define BCRYPT_SIGNATURE_LENGTH u"SignatureLength"
#define BCRYPT_HASH_BLOCK_LENGTH u"HashBlockLength"
#define BCRYPT_AUTH_TAG_LENGTH u"AuthTagLength"
#define BCRYPT_PRIMITIVE_TYPE u"PrimitiveType"
#define BCRYPT_IS_KEYED_HASH u"IsKeyedHash"
#define BCRYPT_KEY_DATA_BLOB u"KeyDataBlob"
#define BCRYPT_BLOCK_PADDING 0x00000001

4
winpr/libwinpr/bcrypt/CMakeLists.txt
View File

@@ -16,3 +16,7 @@
# limitations under the License.
winpr_module_add(bcrypt.c)
if(BUILD_TESTING_INTERNAL OR BUILD_TESTING)
add_subdirectory(test)
endif()

21
winpr/libwinpr/bcrypt/test/CMakeLists.txt Normal file
View File

@@ -0,0 +1,21 @@
set(MODULE_NAME "TestBCrypt")
disable_warnings_for_directory(${CMAKE_CURRENT_BINARY_DIR})
set(DRIVER ${MODULE_NAME}.c)
set(TESTS TestBCryptDefine.c)
create_test_sourcelist(SRCS ${DRIVER} ${TESTS})
add_executable(${MODULE_NAME} ${SRCS})
target_link_libraries(${MODULE_NAME} winpr)
set_target_properties(${MODULE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${TESTING_OUTPUT_DIRECTORY}")
foreach(test ${TESTS})
get_filename_component(TestName ${test} NAME_WE)
add_test(${TestName} ${TESTING_OUTPUT_DIRECTORY}/${MODULE_NAME} ${TestName})
endforeach()
set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "WinPR/Test")

129
winpr/libwinpr/bcrypt/test/TestBCryptDefine.c Normal file
View File

@@ -0,0 +1,129 @@
#include <stdio.h>
#include <winpr/string.h>
#include <winpr/bcrypt.h>
#define STR(x) #x
static BOOL test_wchar_len(void)
{
struct test_case
{
size_t bytelen;
const char* name;
const WCHAR* value;
};
const struct test_case test_cases[] = {
{ sizeof(BCRYPT_RSA_ALGORITHM), STR(BCRYPT_RSA_ALGORITHM), BCRYPT_RSA_ALGORITHM },
{ sizeof(BCRYPT_RSA_SIGN_ALGORITHM), STR(BCRYPT_RSA_SIGN_ALGORITHM),
BCRYPT_RSA_SIGN_ALGORITHM },
{ sizeof(BCRYPT_DH_ALGORITHM), STR(BCRYPT_DH_ALGORITHM), BCRYPT_DH_ALGORITHM },
{ sizeof(BCRYPT_DSA_ALGORITHM), STR(BCRYPT_DSA_ALGORITHM), BCRYPT_DSA_ALGORITHM },
{ sizeof(BCRYPT_RC2_ALGORITHM), STR(BCRYPT_RC2_ALGORITHM), BCRYPT_RC2_ALGORITHM },
{ sizeof(BCRYPT_RC4_ALGORITHM), STR(BCRYPT_RC4_ALGORITHM), BCRYPT_RC4_ALGORITHM },
{ sizeof(BCRYPT_AES_ALGORITHM), STR(BCRYPT_AES_ALGORITHM), BCRYPT_AES_ALGORITHM },
{ sizeof(BCRYPT_DES_ALGORITHM), STR(BCRYPT_DES_ALGORITHM), BCRYPT_DES_ALGORITHM },
{ sizeof(BCRYPT_DESX_ALGORITHM), STR(BCRYPT_DESX_ALGORITHM), BCRYPT_DESX_ALGORITHM },
{ sizeof(BCRYPT_3DES_ALGORITHM), STR(BCRYPT_3DES_ALGORITHM), BCRYPT_3DES_ALGORITHM },
{ sizeof(BCRYPT_3DES_112_ALGORITHM), STR(BCRYPT_3DES_112_ALGORITHM),
BCRYPT_3DES_112_ALGORITHM },
{ sizeof(BCRYPT_MD2_ALGORITHM), STR(BCRYPT_MD2_ALGORITHM), BCRYPT_MD2_ALGORITHM },
{ sizeof(BCRYPT_MD4_ALGORITHM), STR(BCRYPT_MD4_ALGORITHM), BCRYPT_MD4_ALGORITHM },
{ sizeof(BCRYPT_MD5_ALGORITHM), STR(BCRYPT_MD5_ALGORITHM), BCRYPT_MD5_ALGORITHM },
{ sizeof(BCRYPT_SHA1_ALGORITHM), STR(BCRYPT_SHA1_ALGORITHM), BCRYPT_SHA1_ALGORITHM },
{ sizeof(BCRYPT_SHA256_ALGORITHM), STR(BCRYPT_SHA256_ALGORITHM), BCRYPT_SHA256_ALGORITHM },
{ sizeof(BCRYPT_SHA384_ALGORITHM), STR(BCRYPT_SHA384_ALGORITHM), BCRYPT_SHA384_ALGORITHM },
{ sizeof(BCRYPT_SHA512_ALGORITHM), STR(BCRYPT_SHA512_ALGORITHM), BCRYPT_SHA512_ALGORITHM },
{ sizeof(BCRYPT_AES_GMAC_ALGORITHM), STR(BCRYPT_AES_GMAC_ALGORITHM),
BCRYPT_AES_GMAC_ALGORITHM },
{ sizeof(BCRYPT_AES_CMAC_ALGORITHM), STR(BCRYPT_AES_CMAC_ALGORITHM),
BCRYPT_AES_CMAC_ALGORITHM },
{ sizeof(BCRYPT_ECDSA_P256_ALGORITHM), STR(BCRYPT_ECDSA_P256_ALGORITHM),
BCRYPT_ECDSA_P256_ALGORITHM },
{ sizeof(BCRYPT_ECDSA_P384_ALGORITHM), STR(BCRYPT_ECDSA_P384_ALGORITHM),
BCRYPT_ECDSA_P384_ALGORITHM },
{ sizeof(BCRYPT_ECDSA_P521_ALGORITHM), STR(BCRYPT_ECDSA_P521_ALGORITHM),
BCRYPT_ECDSA_P521_ALGORITHM },
{ sizeof(BCRYPT_ECDH_P256_ALGORITHM), STR(BCRYPT_ECDH_P256_ALGORITHM),
BCRYPT_ECDH_P256_ALGORITHM },
{ sizeof(BCRYPT_ECDH_P384_ALGORITHM), STR(BCRYPT_ECDH_P384_ALGORITHM),
BCRYPT_ECDH_P384_ALGORITHM },
{ sizeof(BCRYPT_ECDH_P521_ALGORITHM), STR(BCRYPT_ECDH_P521_ALGORITHM),
BCRYPT_ECDH_P521_ALGORITHM },
{ sizeof(BCRYPT_RNG_ALGORITHM), STR(BCRYPT_RNG_ALGORITHM), BCRYPT_RNG_ALGORITHM },
{ sizeof(BCRYPT_RNG_FIPS186_DSA_ALGORITHM), STR(BCRYPT_RNG_FIPS186_DSA_ALGORITHM),
BCRYPT_RNG_FIPS186_DSA_ALGORITHM },
{ sizeof(BCRYPT_RNG_DUAL_EC_ALGORITHM), STR(BCRYPT_RNG_DUAL_EC_ALGORITHM),
BCRYPT_RNG_DUAL_EC_ALGORITHM },
// The following algorithms are only supported on windows 10 onward.
#if !defined(_WIN32) || _WIN32_WINNT >= 0x0A00
{ sizeof(BCRYPT_ECDSA_ALGORITHM), STR(BCRYPT_ECDSA_ALGORITHM), BCRYPT_ECDSA_ALGORITHM },
{ sizeof(BCRYPT_ECDH_ALGORITHM), STR(BCRYPT_ECDH_ALGORITHM), BCRYPT_ECDH_ALGORITHM },
{ sizeof(BCRYPT_XTS_AES_ALGORITHM), STR(BCRYPT_XTS_AES_ALGORITHM),
BCRYPT_XTS_AES_ALGORITHM },
#endif
{ sizeof(MS_PRIMITIVE_PROVIDER), STR(MS_PRIMITIVE_PROVIDER), MS_PRIMITIVE_PROVIDER },
{ sizeof(MS_PLATFORM_CRYPTO_PROVIDER), STR(MS_PLATFORM_CRYPTO_PROVIDER),
MS_PLATFORM_CRYPTO_PROVIDER },
{ sizeof(BCRYPT_OBJECT_LENGTH), STR(BCRYPT_OBJECT_LENGTH), BCRYPT_OBJECT_LENGTH },
{ sizeof(BCRYPT_ALGORITHM_NAME), STR(BCRYPT_ALGORITHM_NAME), BCRYPT_ALGORITHM_NAME },
{ sizeof(BCRYPT_PROVIDER_HANDLE), STR(BCRYPT_PROVIDER_HANDLE), BCRYPT_PROVIDER_HANDLE },
{ sizeof(BCRYPT_CHAINING_MODE), STR(BCRYPT_CHAINING_MODE), BCRYPT_CHAINING_MODE },
{ sizeof(BCRYPT_BLOCK_LENGTH), STR(BCRYPT_BLOCK_LENGTH), BCRYPT_BLOCK_LENGTH },
{ sizeof(BCRYPT_KEY_LENGTH), STR(BCRYPT_KEY_LENGTH), BCRYPT_KEY_LENGTH },
{ sizeof(BCRYPT_KEY_OBJECT_LENGTH), STR(BCRYPT_KEY_OBJECT_LENGTH),
BCRYPT_KEY_OBJECT_LENGTH },
{ sizeof(BCRYPT_KEY_STRENGTH), STR(BCRYPT_KEY_STRENGTH), BCRYPT_KEY_STRENGTH },
{ sizeof(BCRYPT_KEY_LENGTHS), STR(BCRYPT_KEY_LENGTHS), BCRYPT_KEY_LENGTHS },
{ sizeof(BCRYPT_BLOCK_SIZE_LIST), STR(BCRYPT_BLOCK_SIZE_LIST), BCRYPT_BLOCK_SIZE_LIST },
{ sizeof(BCRYPT_EFFECTIVE_KEY_LENGTH), STR(BCRYPT_EFFECTIVE_KEY_LENGTH),
BCRYPT_EFFECTIVE_KEY_LENGTH },
{ sizeof(BCRYPT_HASH_LENGTH), STR(BCRYPT_HASH_LENGTH), BCRYPT_HASH_LENGTH },
{ sizeof(BCRYPT_HASH_OID_LIST), STR(BCRYPT_HASH_OID_LIST), BCRYPT_HASH_OID_LIST },
{ sizeof(BCRYPT_PADDING_SCHEMES), STR(BCRYPT_PADDING_SCHEMES), BCRYPT_PADDING_SCHEMES },
{ sizeof(BCRYPT_SIGNATURE_LENGTH), STR(BCRYPT_SIGNATURE_LENGTH), BCRYPT_SIGNATURE_LENGTH },
{ sizeof(BCRYPT_HASH_BLOCK_LENGTH), STR(BCRYPT_HASH_BLOCK_LENGTH),
BCRYPT_HASH_BLOCK_LENGTH },
{ sizeof(BCRYPT_AUTH_TAG_LENGTH), STR(BCRYPT_AUTH_TAG_LENGTH), BCRYPT_AUTH_TAG_LENGTH },
{ sizeof(BCRYPT_PRIMITIVE_TYPE), STR(BCRYPT_PRIMITIVE_TYPE), BCRYPT_PRIMITIVE_TYPE },
{ sizeof(BCRYPT_IS_KEYED_HASH), STR(BCRYPT_IS_KEYED_HASH), BCRYPT_IS_KEYED_HASH },
{ sizeof(BCRYPT_KEY_DATA_BLOB), STR(BCRYPT_KEY_DATA_BLOB), BCRYPT_KEY_DATA_BLOB }
};
BOOL rc = TRUE;
for (size_t x = 0; x < ARRAYSIZE(test_cases); x++)
{
const struct test_case* cur = &test_cases[x];
// sizeof(WCHAR) == 2, so all strings must have even byte length
if (cur->bytelen % 2 != 0)
{
(void)fprintf(stderr, "[%s] invalid bytelength %" PRIuz, cur->name, cur->bytelen);
rc = FALSE;
continue;
}
// each string must be '\0' terminated
const size_t len = _wcsnlen(cur->value, cur->bytelen / sizeof(WCHAR));
if (len == cur->bytelen / sizeof(WCHAR))
{
(void)fprintf(stderr, "[%s] missing '\0' termination", cur->name);
rc = FALSE;
continue;
}
}
return rc;
}
int TestBCryptDefine(int argc, char* argv[])
{
WINPR_UNUSED(argc);
WINPR_UNUSED(argv);
if (!test_wchar_len())
return -1;
return 0;
}