From 1ce95abdcd2bf89e3ff6eedf4d9a1b5fbcc42fc2 Mon Sep 17 00:00:00 2001 From: Daniel Pouzzner Date: Fri, 6 Mar 2026 14:32:06 -0600 Subject: [PATCH 1/2] wolfssl/wolfcrypt/error-crypt.h: add do-nothing WC_ERR_TRACE() fallthrough definition to make WC_ERR_TRACE() safe to use ungated in code. --- wolfssl/wolfcrypt/error-crypt.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/wolfssl/wolfcrypt/error-crypt.h b/wolfssl/wolfcrypt/error-crypt.h index f879aabc3b..844035da9c 100644 --- a/wolfssl/wolfcrypt/error-crypt.h +++ b/wolfssl/wolfcrypt/error-crypt.h @@ -365,6 +365,9 @@ WOLFSSL_ABI WOLFSSL_API const char* wc_GetErrorString(int error); #include #else #define WC_NO_ERR_TRACE(label) (label) + #ifndef WC_ERR_TRACE + #define WC_ERR_TRACE(label) (label) + #endif #endif #ifdef __cplusplus From c573ccb23548e6242e4b7cdd7dc8db5622b72c5f Mon Sep 17 00:00:00 2001 From: Daniel Pouzzner Date: Fri, 6 Mar 2026 16:30:10 -0600 Subject: [PATCH 2/2] refactor wc_Hash* so that known wc_HashType values are unconditionally defined in enum wc_HashType, and always either succeed if used properly, or return HASH_TYPE_E if gated out or used improperly; add detailed error code tracing in wolfcrypt/src/hash.c. --- configure.ac | 15 + tests/api/test_hash.c | 129 +++---- wolfcrypt/src/evp.c | 118 +++---- wolfcrypt/src/hash.c | 701 +++++++++++++++++++++++++++++--------- wolfcrypt/src/pkcs7.c | 10 - wolfcrypt/src/rsa.c | 18 +- wolfcrypt/test/test.c | 33 +- wolfssl/wolfcrypt/types.h | 46 +-- 8 files changed, 711 insertions(+), 359 deletions(-) diff --git a/configure.ac b/configure.ac index 9f6f6b8a47..fab092f7d4 100644 --- a/configure.ac +++ b/configure.ac @@ -6038,8 +6038,10 @@ AS_CASE([$FIPS_VERSION], [v6|ready|dev],[ # FIPS 140-3 SRTP-KDF AS_IF([test "$FIPS_VERSION" = "dev"], + ENABLED_FIPS_DEV=yes [AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_FIPS_DEV"]) AS_IF([test "$FIPS_VERSION" = "ready"], + ENABLED_FIPS_READY=yes [AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_FIPS_READY"]) AM_CFLAGS="$AM_CFLAGS \ @@ -11048,6 +11050,19 @@ fi LIB_SOCKET_NSL AX_HARDEN_CC_COMPILER_FLAGS +if test "$ENABLED_SELFTEST" = yes || test "$ENABLED_FIPS" = yes +then + if ! test "$ENABLED_FIPS_DEV" = yes && ! test "$ENABLED_FIPS_READY" = yes + then + # rsa.c wc_hash2mgf() switches on enum wc_HashType, which is defined + # outside the FIPS boundary. Unsupported hashes are correctly handled + # by the default clause. + AC_LANG_PUSH([C]) + AX_APPEND_COMPILE_FLAGS([-Wno-switch-enum],,[$ax_append_compile_cflags_extra]) + AC_LANG_POP + fi +fi + # -Wdeprecated-enum-enum-conversion is on by default in C++20, but conflicts with # our use of enum constructs to define fungible constants. if test "$KERNEL_MODE_DEFAULTS" != "yes" diff --git a/tests/api/test_hash.c b/tests/api/test_hash.c index 1fe2e84098..e37400d675 100644 --- a/tests/api/test_hash.c +++ b/tests/api/test_hash.c @@ -102,24 +102,35 @@ static const enum wc_HashType notCompiledHash[] = { WC_HASH_TYPE_SHA3_384, WC_HASH_TYPE_SHA3_512, #endif - WC_HASH_TYPE_NONE /* Dummy value to ensure list is non-zero. */ -}; -static const int notCompiledHashLen = (sizeof(notCompiledHash) / - sizeof(enum wc_HashType)) - 1; - -static const enum wc_HashType notSupportedHash[] = { -#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) +#if !defined(WOLFSSL_SHA3) || !defined(WOLFSSL_SHAKE128) WC_HASH_TYPE_SHAKE128, #endif -#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) +#if !defined(WOLFSSL_SHA3) || !defined(WOLFSSL_SHAKE256) WC_HASH_TYPE_SHAKE256, #endif +#if defined(NO_MD5) || defined(NO_SHA) WC_HASH_TYPE_MD5_SHA, +#endif +#ifndef WOLFSSL_MD2 WC_HASH_TYPE_MD2, +#endif +#ifdef NO_MD4 WC_HASH_TYPE_MD4, +#endif +#if !defined(HAVE_BLAKE2) && !defined(HAVE_BLAKE2S) WC_HASH_TYPE_BLAKE2B, +#endif +#if !defined(HAVE_BLAKE2) && !defined(HAVE_BLAKE2B) WC_HASH_TYPE_BLAKE2S, - WC_HASH_TYPE_NONE +#endif + WC_HASH_TYPE_NONE /* Dummy value to ensure list is non-zero. */ +}; +static const int notCompiledHashLen = (sizeof(notCompiledHash) / + sizeof(enum wc_HashType)) - 1; + +static const int notSupportedHash[] = { + WC_HASH_TYPE_NONE, + WC_HASH_TYPE_MAX + 1 }; static const int notSupportedHashLen = (sizeof(notSupportedHash) / sizeof(enum wc_HashType)); @@ -156,18 +167,15 @@ static const enum wc_HashType sizeNotCompiledHash[] = { WC_HASH_TYPE_BLAKE2B, WC_HASH_TYPE_BLAKE2S, #endif + WC_HASH_TYPE_SHAKE128, + WC_HASH_TYPE_SHAKE256, WC_HASH_TYPE_NONE /* Dummy value to ensure list is non-zero. */ }; static const int sizeNotCompiledHashLen = (sizeof(sizeNotCompiledHash) / sizeof(enum wc_HashType)) - 1; -static const enum wc_HashType sizeNotSupportedHash[] = { -#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) - WC_HASH_TYPE_SHAKE128, -#endif -#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) - WC_HASH_TYPE_SHAKE256, -#endif - WC_HASH_TYPE_NONE +static const int sizeNotSupportedHash[] = { + WC_HASH_TYPE_NONE, + WC_HASH_TYPE_MAX + 1 }; static const int sizeNotSupportedHashLen = (sizeof(sizeNotSupportedHash) / sizeof(enum wc_HashType)); @@ -214,19 +222,19 @@ int test_wc_HashInit(void) for (i = 0; i < notSupportedHashLen; i++) { /* check for null ptr */ - ExpectIntEQ(wc_HashInit(NULL, notSupportedHash[i]), + ExpectIntEQ(wc_HashInit(NULL, (enum wc_HashType)notSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashInit_ex(NULL, notSupportedHash[i], HEAP_HINT, + ExpectIntEQ(wc_HashInit_ex(NULL, (enum wc_HashType)notSupportedHash[i], HEAP_HINT, INVALID_DEVID), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashInit(&hash, notSupportedHash[i]), + ExpectIntEQ(wc_HashInit(&hash, (enum wc_HashType)notSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_HashFree(&hash, notSupportedHash[i]); - ExpectIntEQ(wc_HashInit_ex(&hash, notSupportedHash[i], HEAP_HINT, + wc_HashFree(&hash, (enum wc_HashType)notSupportedHash[i]); + ExpectIntEQ(wc_HashInit_ex(&hash, (enum wc_HashType)notSupportedHash[i], HEAP_HINT, INVALID_DEVID), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_HashFree(&hash, notSupportedHash[i]); + wc_HashFree(&hash, (enum wc_HashType)notSupportedHash[i]); - wc_HashFree(NULL, notSupportedHash[i]); + wc_HashFree(NULL, (enum wc_HashType)notSupportedHash[i]); } /* end of for loop */ #endif @@ -282,25 +290,25 @@ int test_wc_HashUpdate(void) } for (i = 0; i < notSupportedHashLen; i++) { - ExpectIntEQ(wc_HashInit(&hash, notSupportedHash[i]), + ExpectIntEQ(wc_HashInit(&hash, (enum wc_HashType)notSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); /* Invalid parameters */ - ExpectIntEQ(wc_HashUpdate(NULL, notSupportedHash[i], NULL, 1), + ExpectIntEQ(wc_HashUpdate(NULL, (enum wc_HashType)notSupportedHash[i], NULL, 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashUpdate(&hash, notSupportedHash[i], NULL, 1), + ExpectIntEQ(wc_HashUpdate(&hash, (enum wc_HashType)notSupportedHash[i], NULL, 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashUpdate(NULL, notSupportedHash[i], NULL, 0), + ExpectIntEQ(wc_HashUpdate(NULL, (enum wc_HashType)notSupportedHash[i], NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashUpdate(NULL, notSupportedHash[i], (byte*)"a", 1), + ExpectIntEQ(wc_HashUpdate(NULL, (enum wc_HashType)notSupportedHash[i], (byte*)"a", 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashUpdate(&hash, notSupportedHash[i], NULL, 0), + ExpectIntEQ(wc_HashUpdate(&hash, (enum wc_HashType)notSupportedHash[i], NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashUpdate(&hash, notSupportedHash[i], (byte*)"a", 1), + ExpectIntEQ(wc_HashUpdate(&hash, (enum wc_HashType)notSupportedHash[i], (byte*)"a", 1), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_HashFree(&hash, notSupportedHash[i]); + wc_HashFree(&hash, (enum wc_HashType)notSupportedHash[i]); } #if defined(DEBUG_WOLFSSL) && !defined(NO_SHA256) && defined(WOLFSSL_SHA512) @@ -357,21 +365,21 @@ int test_wc_HashFinal(void) } for (i = 0; i < notSupportedHashLen; i++) { - ExpectIntEQ(wc_HashInit(&hash, notSupportedHash[i]), + ExpectIntEQ(wc_HashInit(&hash, (enum wc_HashType)notSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); /* Invalid parameters */ - ExpectIntEQ(wc_HashFinal(NULL, notSupportedHash[i], NULL), + ExpectIntEQ(wc_HashFinal(NULL, (enum wc_HashType)notSupportedHash[i], NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashFinal(&hash, notSupportedHash[i], NULL), + ExpectIntEQ(wc_HashFinal(&hash, (enum wc_HashType)notSupportedHash[i], NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashFinal(NULL, notSupportedHash[i], digest), + ExpectIntEQ(wc_HashFinal(NULL, (enum wc_HashType)notSupportedHash[i], digest), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashFinal(&hash, notSupportedHash[i], digest), + ExpectIntEQ(wc_HashFinal(&hash, (enum wc_HashType)notSupportedHash[i], digest), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - wc_HashFree(&hash, notSupportedHash[i]); + wc_HashFree(&hash, (enum wc_HashType)notSupportedHash[i]); } #if defined(DEBUG_WOLFSSL) && !defined(NO_SHA256) && defined(WOLFSSL_SHA512) ExpectIntEQ(wc_HashInit(&hash, WC_HASH_TYPE_SHA256), 0); @@ -417,7 +425,7 @@ int test_wc_HashNewDelete(void) } for (i = 0; i < notSupportedHashLen; i++) { - ExpectNull(wc_HashNew(notSupportedHash[i], HEAP_HINT, INVALID_DEVID, + ExpectNull(wc_HashNew((enum wc_HashType)notSupportedHash[i], HEAP_HINT, INVALID_DEVID, &ret)); ExpectIntEQ(ret, WC_NO_ERR_TRACE(BAD_FUNC_ARG)); } @@ -438,17 +446,13 @@ int test_wc_HashGetDigestSize(void) ExpectIntGT(wc_HashGetDigestSize(sizeSupportedHash[i]), 0); } - for (i = 0; i < notCompiledHashLen; i++) { - ExpectIntEQ(wc_HashGetDigestSize(notCompiledHash[i]), - WC_NO_ERR_TRACE(HASH_TYPE_E)); - } for (i = 0; i < sizeNotCompiledHashLen; i++) { ExpectIntEQ(wc_HashGetDigestSize(sizeNotCompiledHash[i]), WC_NO_ERR_TRACE(HASH_TYPE_E)); } for (i = 0; i < sizeNotSupportedHashLen; i++) { - ExpectIntEQ(wc_HashGetDigestSize(sizeNotSupportedHash[i]), + ExpectIntEQ(wc_HashGetDigestSize((enum wc_HashType)sizeNotSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); } #endif @@ -468,17 +472,13 @@ int test_wc_HashGetBlockSize(void) ExpectIntGT(wc_HashGetBlockSize(sizeSupportedHash[i]), 0); } - for (i = 0; i < notCompiledHashLen; i++) { - ExpectIntEQ(wc_HashGetBlockSize(notCompiledHash[i]), - WC_NO_ERR_TRACE(HASH_TYPE_E)); - } for (i = 0; i < sizeNotCompiledHashLen; i++) { ExpectIntEQ(wc_HashGetBlockSize(sizeNotCompiledHash[i]), WC_NO_ERR_TRACE(HASH_TYPE_E)); } for (i = 0; i < sizeNotSupportedHashLen; i++) { - ExpectIntEQ(wc_HashGetBlockSize(sizeNotSupportedHash[i]), + ExpectIntEQ(wc_HashGetBlockSize((enum wc_HashType)sizeNotSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); } #endif @@ -525,9 +525,9 @@ int test_wc_Hash(void) /* Algorithm only supported with wc_Hash() and wc_Hash_ex(). */ continue; } - ExpectIntEQ(wc_Hash(sizeNotSupportedHash[i], (byte*)"a", 1, + ExpectIntEQ(wc_Hash((enum wc_HashType)sizeNotSupportedHash[i], (byte*)"a", 1, digest, sizeof(digest)), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_Hash_ex(sizeNotSupportedHash[i], (byte*)"a", 1, + ExpectIntEQ(wc_Hash_ex((enum wc_HashType)sizeNotSupportedHash[i], (byte*)"a", 1, digest, sizeof(digest), HEAP_HINT, INVALID_DEVID), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); } @@ -570,11 +570,11 @@ int test_wc_HashSetFlags(void) /* For loop to test not supported cases */ for (i = 0; i < notSupportedHashLen; i++) { - ExpectIntEQ(wc_HashInit(&hash, notSupportedHash[i]), + ExpectIntEQ(wc_HashInit(&hash, (enum wc_HashType)notSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashSetFlags(&hash, notSupportedHash[i], flags), + ExpectIntEQ(wc_HashSetFlags(&hash, (enum wc_HashType)notSupportedHash[i], flags), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashFree(&hash, notSupportedHash[i]), + ExpectIntEQ(wc_HashFree(&hash, (enum wc_HashType)notSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); } #endif @@ -613,11 +613,11 @@ int test_wc_HashGetFlags(void) /* For loop to test not supported cases */ for (i = 0; i < notSupportedHashLen; i++) { - ExpectIntEQ(wc_HashInit(&hash, notSupportedHash[i]), + ExpectIntEQ(wc_HashInit(&hash, (enum wc_HashType)notSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashGetFlags(&hash, notSupportedHash[i], &flags), + ExpectIntEQ(wc_HashGetFlags(&hash, (enum wc_HashType)notSupportedHash[i], &flags), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); - ExpectIntEQ(wc_HashFree(&hash, notSupportedHash[i]), + ExpectIntEQ(wc_HashFree(&hash, (enum wc_HashType)notSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); } #endif @@ -682,7 +682,7 @@ int test_wc_HashGetOID(void) #ifdef WOLFSSL_MD2 WC_HASH_TYPE_MD2, #endif - #ifndef NO_MD5 + #if !defined(NO_MD5) && !defined(NO_SHA) WC_HASH_TYPE_MD5_SHA, #endif WC_HASH_TYPE_NONE /* Dummy value to ensure list is non-zero. */ @@ -696,15 +696,16 @@ int test_wc_HashGetOID(void) #ifdef NO_MD5 WC_HASH_TYPE_MD5_SHA, #endif + WC_HASH_TYPE_MD4, + WC_HASH_TYPE_BLAKE2B, + WC_HASH_TYPE_BLAKE2S, WC_HASH_TYPE_NONE /* Dummy value to ensure list is non-zero. */ }; static const int oidOnlyNotCompiledHashLen = (sizeof(oidOnlyNotCompiledHash) / sizeof(enum wc_HashType)) - 1; - static const enum wc_HashType oidNotSupportedHash[] = { - WC_HASH_TYPE_MD4, - WC_HASH_TYPE_BLAKE2B, - WC_HASH_TYPE_BLAKE2S, - WC_HASH_TYPE_NONE + static const int oidNotSupportedHash[] = { + WC_HASH_TYPE_NONE, + WC_HASH_TYPE_MAX + 1 }; static const int oidNotSupportedHashLen = (sizeof(oidNotSupportedHash) / sizeof(enum wc_HashType)); @@ -727,7 +728,7 @@ int test_wc_HashGetOID(void) } for (i = 0; i < oidNotSupportedHashLen; i++) { - ExpectIntEQ(wc_HashGetOID(oidNotSupportedHash[i]), + ExpectIntEQ(wc_HashGetOID((enum wc_HashType)oidNotSupportedHash[i]), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); } #endif diff --git a/wolfcrypt/src/evp.c b/wolfcrypt/src/evp.c index 1399468a72..5f7ed7c9a8 100644 --- a/wolfcrypt/src/evp.c +++ b/wolfcrypt/src/evp.c @@ -5752,28 +5752,24 @@ void wolfSSL_EVP_init(void) ret = NOT_COMPILED_IN; #endif /* WOLFSSL_SHA512 */ break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) ret = wc_Sha512_224Copy((wc_Sha512*)&src->hash.digest, (wc_Sha512*)&des->hash.digest); #else ret = NOT_COMPILED_IN; #endif break; - #endif /* !WOLFSSL_NOSHA512_224 */ - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) ret = wc_Sha512_256Copy((wc_Sha512*)&src->hash.digest, (wc_Sha512*)&des->hash.digest); #else ret = NOT_COMPILED_IN; #endif break; - #endif /* !WOLFSSL_NOSHA512_256 */ case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) ret = wc_Sha3_224_Copy((wc_Sha3*)&src->hash.digest, @@ -5806,24 +5802,22 @@ void wolfSSL_EVP_init(void) ret = NOT_COMPILED_IN; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: + #ifdef WOLFSSL_SM3 ret = wc_Sm3Copy(&src->hash.digest.sm3, &des->hash.digest.sm3); - break; + #else + ret = NOT_COMPILED_IN; #endif + break; case WC_HASH_TYPE_NONE: case WC_HASH_TYPE_MD2: case WC_HASH_TYPE_MD4: case WC_HASH_TYPE_MD5_SHA: case WC_HASH_TYPE_BLAKE2B: case WC_HASH_TYPE_BLAKE2S: - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) case WC_HASH_TYPE_SHAKE256: - #endif default: ret = BAD_FUNC_ARG; break; @@ -10677,22 +10671,18 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) wc_Sha512Free((wc_Sha512*)&ctx->hash.digest); #endif /* WOLFSSL_SHA512 */ break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) wc_Sha512_224Free((wc_Sha512*)&ctx->hash.digest); #endif break; - #endif /* !WOLFSSL_NOSHA512_224 */ - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: - #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) + #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) wc_Sha512_256Free((wc_Sha512*)&ctx->hash.digest); #endif break; - #endif /* !WOLFSSL_NOSHA512_256 */ case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) wc_Sha3_224_Free((wc_Sha3*)&ctx->hash.digest); @@ -10713,25 +10703,25 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) wc_Sha3_512_Free((wc_Sha3*)&ctx->hash.digest); #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: + #ifdef WOLFSSL_SM3 wc_Sm3Free(&ctx->hash.digest.sm3); - break; #endif + break; case WC_HASH_TYPE_NONE: /* Not an error since an unused struct could be free'd or * reset. */ break; - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) case WC_HASH_TYPE_SHAKE128: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) wc_Shake128_Free(&ctx->hash.digest.shake); - break; #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + break; case WC_HASH_TYPE_SHAKE256: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) wc_Shake256_Free(&ctx->hash.digest.shake); - break; #endif + break; case WC_HASH_TYPE_MD2: case WC_HASH_TYPE_MD4: case WC_HASH_TYPE_MD5_SHA: @@ -10928,25 +10918,25 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) #endif /* WOLFSSL_SHA512 */ break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) ret = wolfSSL_SHA512_224_Update((WOLFSSL_SHA512_CTX*)&ctx->hash, data, (unsigned long)sz); + #else + ret = NOT_COMPILED_IN; #endif break; - #endif /* !WOLFSSL_NOSHA512_224 */ - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) ret = wolfSSL_SHA512_256_Update((WOLFSSL_SHA512_CTX*)&ctx->hash, data, (unsigned long)sz); + #else + ret = NOT_COMPILED_IN; #endif /* WOLFSSL_SHA512 */ break; - #endif /* !WOLFSSL_NOSHA512_256 */ case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) @@ -10972,8 +10962,8 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) (unsigned long)sz); #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: + #ifdef WOLFSSL_SM3 ret = wc_Sm3Update(&ctx->hash.digest.sm3, data, (word32)sz); if (ret == 0) { ret = WOLFSSL_SUCCESS; @@ -10981,25 +10971,31 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) else { ret = WOLFSSL_FAILURE; } - break; + #else + ret = NOT_COMPILED_IN; #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) + break; case WC_HASH_TYPE_SHAKE128: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) if (wc_Shake128_Update(&ctx->hash.digest.shake, (const byte*)data, (word32)sz) == 0) { ret = WOLFSSL_SUCCESS; } - break; + #else + ret = NOT_COMPILED_IN; #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + break; case WC_HASH_TYPE_SHAKE256: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) if (wc_Shake256_Update(&ctx->hash.digest.shake, (const byte*)data, (word32)sz) == 0) { ret = WOLFSSL_SUCCESS; } - break; + #else + ret = NOT_COMPILED_IN; #endif + break; case WC_HASH_TYPE_NONE: case WC_HASH_TYPE_MD2: case WC_HASH_TYPE_MD5_SHA: @@ -11062,24 +11058,24 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) if (s) *s = WC_SHA512_DIGEST_SIZE; #endif /* WOLFSSL_SHA512 */ break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) ret = wolfSSL_SHA512_224_Final(md, (WOLFSSL_SHA512_CTX*)&ctx->hash); if (s) *s = WC_SHA512_224_DIGEST_SIZE; + #else + ret = NOT_COMPILED_IN; #endif break; - #endif /* !WOLFSSL_NOSHA512_224 */ - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ - defined(WOLFSSL_SHA512) + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) ret = wolfSSL_SHA512_256_Final(md, (WOLFSSL_SHA512_CTX*)&ctx->hash); if (s) *s = WC_SHA512_256_DIGEST_SIZE; + #else + ret = NOT_COMPILED_IN; #endif break; - #endif /* !WOLFSSL_NOSHA512_256 */ case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) ret = wolfSSL_SHA3_224_Final(md, (WOLFSSL_SHA3_224_CTX*)&ctx->hash); @@ -11104,8 +11100,8 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) if (s) *s = WC_SHA3_512_DIGEST_SIZE; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: + #ifdef WOLFSSL_SM3 ret = wc_Sm3Final(&ctx->hash.digest.sm3, md); if (ret == 0) { ret = WOLFSSL_SUCCESS; @@ -11114,22 +11110,28 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) ret = WOLFSSL_FAILURE; } if (s) *s = WC_SM3_DIGEST_SIZE; - break; + #else + ret = NOT_COMPILED_IN; #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) + break; case WC_HASH_TYPE_SHAKE128: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) if (wc_Shake128_Final(&ctx->hash.digest.shake, md, *s) == 0) { ret = WOLFSSL_SUCCESS; } - break; + #else + ret = NOT_COMPILED_IN; #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + break; case WC_HASH_TYPE_SHAKE256: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) if (wc_Shake256_Final(&ctx->hash.digest.shake, md, *s) == 0) { ret = WOLFSSL_SUCCESS; } - break; + #else + ret = NOT_COMPILED_IN; #endif + break; case WC_HASH_TYPE_NONE: case WC_HASH_TYPE_MD2: case WC_HASH_TYPE_MD5_SHA: @@ -11157,19 +11159,13 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) case WC_HASH_TYPE_SHA256: case WC_HASH_TYPE_SHA384: case WC_HASH_TYPE_SHA512: - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: - #endif /* !WOLFSSL_NOSHA512_224 */ - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: - #endif /* !WOLFSSL_NOSHA512_256 */ case WC_HASH_TYPE_SHA3_224: case WC_HASH_TYPE_SHA3_256: case WC_HASH_TYPE_SHA3_384: case WC_HASH_TYPE_SHA3_512: - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: - #endif case WC_HASH_TYPE_NONE: case WC_HASH_TYPE_MD2: case WC_HASH_TYPE_MD5_SHA: @@ -11177,18 +11173,22 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD* type) case WC_HASH_TYPE_BLAKE2S: break; - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) case WC_HASH_TYPE_SHAKE128: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) *s = 16; /* if mixing up XOF with plain digest 128 bit is * default for SHAKE128 */ - break; + #else + return WOLFSSL_FAILURE; #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + break; case WC_HASH_TYPE_SHAKE256: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) *s = 32; /* if mixing up XOF with plain digest 256 bit is * default for SHAKE256 */ - break; + #else + return WOLFSSL_FAILURE; #endif + break; default: return WOLFSSL_FAILURE; } diff --git a/wolfcrypt/src/hash.c b/wolfcrypt/src/hash.c index e82c6f6ac3..d87a081b28 100644 --- a/wolfcrypt/src/hash.c +++ b/wolfcrypt/src/hash.c @@ -118,100 +118,143 @@ enum wc_HashType wc_HashTypeConvert(int hashType) int wc_HashGetOID(enum wc_HashType hash_type) { - int oid = WC_NO_ERR_TRACE(HASH_TYPE_E); /* Default to hash type error */ + int oid; switch(hash_type) { case WC_HASH_TYPE_MD2: #ifdef WOLFSSL_MD2 oid = MD2h; + #else + oid = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_MD5_SHA: + #if !defined(NO_MD5) && !defined(NO_SHA) + oid = MD5h; + #else + oid = HASH_TYPE_E; + #endif + break; case WC_HASH_TYPE_MD5: #ifndef NO_MD5 oid = MD5h; + #else + oid = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA oid = SHAh; + #else + oid = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 oid = SHA224h; + #else + oid = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 oid = SHA256h; + #else + oid = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 oid = SHA384h; + #else + oid = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: #ifdef WOLFSSL_SHA512 oid = SHA512h; + #else + oid = HASH_TYPE_E; #endif break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) oid = SHA512_224h; + #else + oid = HASH_TYPE_E; #endif break; - #endif - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) oid = SHA512_256h; + #else + oid = HASH_TYPE_E; #endif break; - #endif case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) oid = SHA3_224h; + #else + oid = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_256: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) oid = SHA3_256h; + #else + oid = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_384: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) oid = SHA3_384h; + #else + oid = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_512: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) oid = SHA3_512h; + #else + oid = HASH_TYPE_E; #endif break; - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) case WC_HASH_TYPE_SHAKE128: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) oid = SHAKE128h; + #else + oid = HASH_TYPE_E; + #endif break; - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) case WC_HASH_TYPE_SHAKE256: + #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) oid = SHAKE256h; + #else + oid = HASH_TYPE_E; + #endif break; - #endif - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: + #ifdef WOLFSSL_SM3 oid = SM3h; + #else + oid = HASH_TYPE_E; + #endif break; - #endif /* Not Supported */ case WC_HASH_TYPE_MD4: + oid = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2B: + oid = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2S: + oid = HASH_TYPE_E; + break; + case WC_HASH_TYPE_NONE: + oid = BAD_FUNC_ARG; + break; default: oid = BAD_FUNC_ARG; break; @@ -221,64 +264,95 @@ int wc_HashGetOID(enum wc_HashType hash_type) enum wc_HashType wc_OidGetHash(int oid) { - enum wc_HashType hash_type = WC_HASH_TYPE_NONE; + enum wc_HashType hash_type; switch (oid) { - #ifdef WOLFSSL_MD2 case MD2h: + #ifdef WOLFSSL_MD2 hash_type = WC_HASH_TYPE_MD2; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); + #endif break; - #endif case MD5h: #ifndef NO_MD5 hash_type = WC_HASH_TYPE_MD5; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); #endif break; case SHAh: #ifndef NO_SHA hash_type = WC_HASH_TYPE_SHA; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); #endif break; case SHA224h: #ifdef WOLFSSL_SHA224 hash_type = WC_HASH_TYPE_SHA224; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); #endif break; case SHA256h: #ifndef NO_SHA256 hash_type = WC_HASH_TYPE_SHA256; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); #endif break; case SHA384h: #ifdef WOLFSSL_SHA384 hash_type = WC_HASH_TYPE_SHA384; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); #endif break; case SHA512h: #ifdef WOLFSSL_SHA512 hash_type = WC_HASH_TYPE_SHA512; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); #endif break; - #ifdef WOLFSSL_SHA3 case SHA3_224h: + #ifdef WOLFSSL_SHA3 hash_type = WC_HASH_TYPE_SHA3_224; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); + #endif break; case SHA3_256h: + #ifdef WOLFSSL_SHA3 hash_type = WC_HASH_TYPE_SHA3_256; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); + #endif break; case SHA3_384h: + #ifdef WOLFSSL_SHA3 hash_type = WC_HASH_TYPE_SHA3_384; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); + #endif break; + #ifdef WOLFSSL_SHA3 case SHA3_512h: hash_type = WC_HASH_TYPE_SHA3_512; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); + #endif break; - #endif /* WOLFSSL_SHA3 */ - #ifdef WOLFSSL_SM3 case SM3h: + #ifdef WOLFSSL_SM3 hash_type = WC_HASH_TYPE_SM3; + #else + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); + #endif break; - #endif default: + hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE); break; } return hash_type; @@ -290,114 +364,145 @@ enum wc_HashType wc_OidGetHash(int oid) /* Get Hash digest size */ int wc_HashGetDigestSize(enum wc_HashType hash_type) { - int dig_size = WC_NO_ERR_TRACE(HASH_TYPE_E); + int dig_size; switch(hash_type) { case WC_HASH_TYPE_MD2: #ifdef WOLFSSL_MD2 dig_size = WC_MD2_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_MD4: #ifndef NO_MD4 dig_size = WC_MD4_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_MD5: #ifndef NO_MD5 dig_size = WC_MD5_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA dig_size = WC_SHA_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 dig_size = WC_SHA224_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 dig_size = WC_SHA256_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 dig_size = WC_SHA384_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: #ifdef WOLFSSL_SHA512 dig_size = WC_SHA512_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) - #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) + #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) dig_size = WC_SHA512_224_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) - #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) + #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) dig_size = WC_SHA512_256_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */ #if !defined(NO_MD5) && !defined(NO_SHA) dig_size = (int)WC_MD5_DIGEST_SIZE + (int)WC_SHA_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) dig_size = WC_SHA3_224_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_256: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) dig_size = WC_SHA3_256_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_384: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) dig_size = WC_SHA3_384_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_512: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) dig_size = WC_SHA3_512_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_BLAKE2B: case WC_HASH_TYPE_BLAKE2S: #if defined(HAVE_BLAKE2) || defined(HAVE_BLAKE2S) dig_size = BLAKE2S_OUTBYTES; + #else + dig_size = HASH_TYPE_E; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: + #ifdef WOLFSSL_SM3 dig_size = WC_SM3_DIGEST_SIZE; + #else + dig_size = HASH_TYPE_E; + #endif break; - #endif /* Not Supported */ - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + dig_size = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE256: - #endif + dig_size = HASH_TYPE_E; + break; + case WC_HASH_TYPE_NONE: + dig_size = BAD_FUNC_ARG; + break; default: dig_size = BAD_FUNC_ARG; break; @@ -409,114 +514,145 @@ int wc_HashGetDigestSize(enum wc_HashType hash_type) /* Get Hash block size */ int wc_HashGetBlockSize(enum wc_HashType hash_type) { - int block_size = WC_NO_ERR_TRACE(HASH_TYPE_E); + int block_size; switch (hash_type) { case WC_HASH_TYPE_MD2: #ifdef WOLFSSL_MD2 block_size = WC_MD2_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_MD4: #ifndef NO_MD4 block_size = WC_MD4_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_MD5: #ifndef NO_MD5 block_size = WC_MD5_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA block_size = WC_SHA_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 block_size = WC_SHA224_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 block_size = WC_SHA256_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 block_size = WC_SHA384_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: #ifdef WOLFSSL_SHA512 block_size = WC_SHA512_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) - #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) + #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) block_size = WC_SHA512_224_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) - #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) + #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) block_size = WC_SHA512_256_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */ #if !defined(NO_MD5) && !defined(NO_SHA) block_size = (int)WC_MD5_BLOCK_SIZE + (int)WC_SHA_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) block_size = WC_SHA3_224_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_256: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) block_size = WC_SHA3_256_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_384: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) block_size = WC_SHA3_384_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_512: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) block_size = WC_SHA3_512_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_BLAKE2B: case WC_HASH_TYPE_BLAKE2S: #if defined(HAVE_BLAKE2) || defined(HAVE_BLAKE2S) block_size = BLAKE2S_BLOCKBYTES; + #else + block_size = HASH_TYPE_E; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: + #ifdef WOLFSSL_SM3 block_size = WC_SM3_BLOCK_SIZE; + #else + block_size = HASH_TYPE_E; + #endif break; - #endif /* Not Supported */ - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + block_size = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE256: - #endif + block_size = HASH_TYPE_E; + break; + case WC_HASH_TYPE_NONE: + block_size = BAD_FUNC_ARG; + break; default: block_size = BAD_FUNC_ARG; break; @@ -528,7 +664,7 @@ int wc_HashGetBlockSize(enum wc_HashType hash_type) int wc_Hash_ex(enum wc_HashType hash_type, const byte* data, word32 data_len, byte* hash, word32 hash_len, void* heap, int devId) { - int ret = WC_NO_ERR_TRACE(HASH_TYPE_E); /* Default to hash type error */ + int ret; int dig_size; /* Validate hash buffer size */ @@ -552,51 +688,61 @@ int wc_Hash_ex(enum wc_HashType hash_type, const byte* data, case WC_HASH_TYPE_MD5: #ifndef NO_MD5 ret = wc_Md5Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA ret = wc_ShaHash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 ret = wc_Sha224Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 ret = wc_Sha256Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 ret = wc_Sha384Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: #ifdef WOLFSSL_SHA512 ret = wc_Sha512Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) ret = wc_Sha512_224Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) ret = wc_Sha512_256Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif case WC_HASH_TYPE_MD5_SHA: #if !defined(NO_MD5) && !defined(NO_SHA) ret = wc_Md5Hash_ex(data, data_len, hash, heap, devId); @@ -604,48 +750,71 @@ int wc_Hash_ex(enum wc_HashType hash_type, const byte* data, ret = wc_ShaHash_ex(data, data_len, &hash[WC_MD5_DIGEST_SIZE], heap, devId); } +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) ret = wc_Sha3_224Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_256: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) ret = wc_Sha3_256Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_384: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) ret = wc_Sha3_384Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_512: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) ret = wc_Sha3_512Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: +#ifdef WOLFSSL_SM3 ret = wc_Sm3Hash_ex(data, data_len, hash, heap, devId); +#else + ret = HASH_TYPE_E; +#endif break; - #endif /* Not Supported */ case WC_HASH_TYPE_MD2: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD4: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2B: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2S: - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE256: - #endif + ret = HASH_TYPE_E; + break; + case WC_HASH_TYPE_NONE: + ret = BAD_FUNC_ARG; + break; default: ret = BAD_FUNC_ARG; break; @@ -700,7 +869,7 @@ int wc_HashDelete(wc_HashAlg *hash, wc_HashAlg **hash_p) { int wc_HashInit_ex(wc_HashAlg* hash, enum wc_HashType type, void* heap, int devId) { - int ret = WC_NO_ERR_TRACE(HASH_TYPE_E); /* Default to hash type error */ + int ret; if (hash == NULL) return BAD_FUNC_ARG; @@ -717,91 +886,124 @@ int wc_HashInit_ex(wc_HashAlg* hash, enum wc_HashType type, void* heap, case WC_HASH_TYPE_MD5: #ifndef NO_MD5 ret = wc_InitMd5_ex(&hash->alg.md5, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA ret = wc_InitSha_ex(&hash->alg.sha, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 ret = wc_InitSha224_ex(&hash->alg.sha224, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 ret = wc_InitSha256_ex(&hash->alg.sha256, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 ret = wc_InitSha384_ex(&hash->alg.sha384, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: #ifdef WOLFSSL_SHA512 ret = wc_InitSha512_ex(&hash->alg.sha512, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) ret = wc_InitSha512_224_ex(&hash->alg.sha512, heap, devId); +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) ret = wc_InitSha512_256_ex(&hash->alg.sha512, heap, devId); +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) ret = wc_InitSha3_224(&hash->alg.sha3, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_256: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) ret = wc_InitSha3_256(&hash->alg.sha3, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_384: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) ret = wc_InitSha3_384(&hash->alg.sha3, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_512: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) ret = wc_InitSha3_512(&hash->alg.sha3, heap, devId); +#else + ret = HASH_TYPE_E; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: +#ifdef WOLFSSL_SM3 ret = wc_InitSm3(&hash->alg.sm3, heap, devId); +#else + ret = HASH_TYPE_E; +#endif break; - #endif /* not supported */ case WC_HASH_TYPE_MD5_SHA: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD2: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD4: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2B: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2S: - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE256: - #endif + ret = HASH_TYPE_E; + break; + case WC_HASH_TYPE_NONE: + ret = BAD_FUNC_ARG; + break; default: ret = BAD_FUNC_ARG; }; @@ -819,7 +1021,7 @@ int wc_HashInit(wc_HashAlg* hash, enum wc_HashType type) int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type, const byte* data, word32 dataSz) { - int ret = WC_NO_ERR_TRACE(HASH_TYPE_E); /* Default to hash type error */ + int ret; if (hash == NULL || (data == NULL && dataSz > 0)) return BAD_FUNC_ARG; @@ -835,91 +1037,124 @@ int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type, const byte* data, case WC_HASH_TYPE_MD5: #ifndef NO_MD5 ret = wc_Md5Update(&hash->alg.md5, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA ret = wc_ShaUpdate(&hash->alg.sha, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 ret = wc_Sha224Update(&hash->alg.sha224, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 ret = wc_Sha256Update(&hash->alg.sha256, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 ret = wc_Sha384Update(&hash->alg.sha384, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: #ifdef WOLFSSL_SHA512 ret = wc_Sha512Update(&hash->alg.sha512, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) ret = wc_Sha512_224Update(&hash->alg.sha512, data, dataSz); +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) ret = wc_Sha512_256Update(&hash->alg.sha512, data, dataSz); +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) ret = wc_Sha3_224_Update(&hash->alg.sha3, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_256: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) ret = wc_Sha3_256_Update(&hash->alg.sha3, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_384: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) ret = wc_Sha3_384_Update(&hash->alg.sha3, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_512: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) ret = wc_Sha3_512_Update(&hash->alg.sha3, data, dataSz); +#else + ret = HASH_TYPE_E; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: +#ifdef WOLFSSL_SM3 ret = wc_Sm3Update(&hash->alg.sm3, data, dataSz); +#else + ret = HASH_TYPE_E; +#endif break; - #endif /* not supported */ case WC_HASH_TYPE_MD5_SHA: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD2: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD4: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2B: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2S: - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE256: - #endif + ret = HASH_TYPE_E; + break; + case WC_HASH_TYPE_NONE: + ret = BAD_FUNC_ARG; + break; default: ret = BAD_FUNC_ARG; }; @@ -929,7 +1164,7 @@ int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type, const byte* data, int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out) { - int ret = WC_NO_ERR_TRACE(HASH_TYPE_E); /* Default to hash type error */ + int ret; if (hash == NULL || out == NULL) return BAD_FUNC_ARG; @@ -945,91 +1180,124 @@ int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out) case WC_HASH_TYPE_MD5: #ifndef NO_MD5 ret = wc_Md5Final(&hash->alg.md5, out); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA ret = wc_ShaFinal(&hash->alg.sha, out); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 ret = wc_Sha224Final(&hash->alg.sha224, out); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 ret = wc_Sha256Final(&hash->alg.sha256, out); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 ret = wc_Sha384Final(&hash->alg.sha384, out); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: #ifdef WOLFSSL_SHA512 ret = wc_Sha512Final(&hash->alg.sha512, out); +#else + ret = HASH_TYPE_E; #endif break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) ret = wc_Sha512_224Final(&hash->alg.sha512, out); +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) ret = wc_Sha512_256Final(&hash->alg.sha512, out); +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) ret = wc_Sha3_224_Final(&hash->alg.sha3, out); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_256: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) ret = wc_Sha3_256_Final(&hash->alg.sha3, out); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_384: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) ret = wc_Sha3_384_Final(&hash->alg.sha3, out); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_512: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) ret = wc_Sha3_512_Final(&hash->alg.sha3, out); +#else + ret = HASH_TYPE_E; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: +#ifdef WOLFSSL_SM3 ret = wc_Sm3Final(&hash->alg.sm3, out); +#else + ret = HASH_TYPE_E; +#endif break; - #endif /* not supported */ case WC_HASH_TYPE_MD5_SHA: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD2: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD4: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2B: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2S: - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE256: - #endif + ret = HASH_TYPE_E; + break; + case WC_HASH_TYPE_NONE: + ret = BAD_FUNC_ARG; + break; default: ret = BAD_FUNC_ARG; }; @@ -1039,7 +1307,7 @@ int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out) int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type) { - int ret = WC_NO_ERR_TRACE(HASH_TYPE_E); /* Default to hash type error */ + int ret; if (hash == NULL) return BAD_FUNC_ARG; @@ -1056,103 +1324,136 @@ int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type) #ifndef NO_MD5 wc_Md5Free(&hash->alg.md5); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA wc_ShaFree(&hash->alg.sha); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 wc_Sha224Free(&hash->alg.sha224); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 wc_Sha256Free(&hash->alg.sha256); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 wc_Sha384Free(&hash->alg.sha384); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: #ifdef WOLFSSL_SHA512 wc_Sha512Free(&hash->alg.sha512); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; - #ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) wc_Sha512_224Free(&hash->alg.sha512); ret = 0; +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif - #ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: -#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) -#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) +#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \ + defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) wc_Sha512_256Free(&hash->alg.sha512); ret = 0; +#else + ret = HASH_TYPE_E; #endif -#endif /* !HAVE_FIPS && !HAVE_SELFTEST */ break; - #endif case WC_HASH_TYPE_SHA3_224: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) wc_Sha3_224_Free(&hash->alg.sha3); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_256: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256) wc_Sha3_256_Free(&hash->alg.sha3); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_384: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384) wc_Sha3_384_Free(&hash->alg.sha3); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA3_512: #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512) wc_Sha3_512_Free(&hash->alg.sha3); ret = 0; +#else + ret = HASH_TYPE_E; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: +#ifdef WOLFSSL_SM3 wc_Sm3Free(&hash->alg.sm3); ret = 0; +#else + ret = HASH_TYPE_E; +#endif break; - #endif /* not supported */ case WC_HASH_TYPE_MD5_SHA: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD2: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD4: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2B: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2S: - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE256: - #endif + ret = HASH_TYPE_E; + break; + case WC_HASH_TYPE_NONE: + ret = BAD_FUNC_ARG; + break; default: ret = BAD_FUNC_ARG; }; @@ -1163,7 +1464,7 @@ int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type) #ifdef WOLFSSL_HASH_FLAGS int wc_HashSetFlags(wc_HashAlg* hash, enum wc_HashType type, word32 flags) { - int ret = WC_NO_ERR_TRACE(HASH_TYPE_E); /* Default to hash type error */ + int ret; if (hash == NULL) return BAD_FUNC_ARG; @@ -1172,37 +1473,59 @@ int wc_HashSetFlags(wc_HashAlg* hash, enum wc_HashType type, word32 flags) case WC_HASH_TYPE_MD5: #ifndef NO_MD5 ret = wc_Md5SetFlags(&hash->alg.md5, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA ret = wc_ShaSetFlags(&hash->alg.sha, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 ret = wc_Sha224SetFlags(&hash->alg.sha224, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 ret = wc_Sha256SetFlags(&hash->alg.sha256, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 ret = wc_Sha384SetFlags(&hash->alg.sha384, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: - #ifndef WOLFSSL_NOSHA512_224 +#ifdef WOLFSSL_SHA512 + ret = wc_Sha512SetFlags(&hash->alg.sha512, flags); +#else + ret = HASH_TYPE_E; +#endif + break; + case WC_HASH_TYPE_SHA512_224: - #endif - #ifndef WOLFSSL_NOSHA512_256 +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) + ret = wc_Sha512SetFlags(&hash->alg.sha512, flags); +#else + ret = HASH_TYPE_E; +#endif + break; + case WC_HASH_TYPE_SHA512_256: - #endif -#ifdef WOLFSSL_SHA512 +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) ret = wc_Sha512SetFlags(&hash->alg.sha512, flags); +#else + ret = HASH_TYPE_E; #endif break; @@ -1212,28 +1535,45 @@ int wc_HashSetFlags(wc_HashAlg* hash, enum wc_HashType type, word32 flags) case WC_HASH_TYPE_SHA3_512: #ifdef WOLFSSL_SHA3 ret = wc_Sha3_SetFlags(&hash->alg.sha3, flags); +#else + ret = HASH_TYPE_E; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: +#ifdef WOLFSSL_SM3 ret = wc_Sm3SetFlags(&hash->alg.sm3, flags); +#else + ret = HASH_TYPE_E; +#endif break; - #endif /* not supported */ case WC_HASH_TYPE_MD5_SHA: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD2: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD4: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2B: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2S: - case WC_HASH_TYPE_NONE: - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE256: - #endif + ret = HASH_TYPE_E; + break; + + case WC_HASH_TYPE_NONE: + ret = BAD_FUNC_ARG; + break; default: ret = BAD_FUNC_ARG; }; @@ -1242,7 +1582,7 @@ int wc_HashSetFlags(wc_HashAlg* hash, enum wc_HashType type, word32 flags) } int wc_HashGetFlags(wc_HashAlg* hash, enum wc_HashType type, word32* flags) { - int ret = WC_NO_ERR_TRACE(HASH_TYPE_E); /* Default to hash type error */ + int ret; if (hash == NULL) return BAD_FUNC_ARG; @@ -1251,37 +1591,57 @@ int wc_HashGetFlags(wc_HashAlg* hash, enum wc_HashType type, word32* flags) case WC_HASH_TYPE_MD5: #ifndef NO_MD5 ret = wc_Md5GetFlags(&hash->alg.md5, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA: #ifndef NO_SHA ret = wc_ShaGetFlags(&hash->alg.sha, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA224: #ifdef WOLFSSL_SHA224 ret = wc_Sha224GetFlags(&hash->alg.sha224, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA256: #ifndef NO_SHA256 ret = wc_Sha256GetFlags(&hash->alg.sha256, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA384: #ifdef WOLFSSL_SHA384 ret = wc_Sha384GetFlags(&hash->alg.sha384, flags); +#else + ret = HASH_TYPE_E; #endif break; case WC_HASH_TYPE_SHA512: - #ifndef WOLFSSL_NOSHA512_224 +#ifdef WOLFSSL_SHA512 + ret = wc_Sha512GetFlags(&hash->alg.sha512, flags); +#else + ret = HASH_TYPE_E; +#endif + break; case WC_HASH_TYPE_SHA512_224: - #endif - #ifndef WOLFSSL_NOSHA512_256 +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224) + ret = wc_Sha512GetFlags(&hash->alg.sha512, flags); +#else + ret = HASH_TYPE_E; +#endif + break; case WC_HASH_TYPE_SHA512_256: - #endif -#ifdef WOLFSSL_SHA512 +#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256) ret = wc_Sha512GetFlags(&hash->alg.sha512, flags); +#else + ret = HASH_TYPE_E; #endif break; @@ -1291,28 +1651,45 @@ int wc_HashGetFlags(wc_HashAlg* hash, enum wc_HashType type, word32* flags) case WC_HASH_TYPE_SHA3_512: #ifdef WOLFSSL_SHA3 ret = wc_Sha3_GetFlags(&hash->alg.sha3, flags); +#else + ret = HASH_TYPE_E; #endif break; - #ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: +#ifdef WOLFSSL_SM3 ret = wc_Sm3GetFlags(&hash->alg.sm3, flags); +#else + ret = HASH_TYPE_E; +#endif break; - #endif /* not supported */ case WC_HASH_TYPE_MD5_SHA: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD2: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_MD4: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2B: + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_BLAKE2S: - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE128: - #endif - #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256) + ret = HASH_TYPE_E; + break; case WC_HASH_TYPE_SHAKE256: - #endif + ret = HASH_TYPE_E; + break; + case WC_HASH_TYPE_NONE: + ret = BAD_FUNC_ARG; + break; default: ret = BAD_FUNC_ARG; }; diff --git a/wolfcrypt/src/pkcs7.c b/wolfcrypt/src/pkcs7.c index 72b77ebde6..b824ac2efe 100644 --- a/wolfcrypt/src/pkcs7.c +++ b/wolfcrypt/src/pkcs7.c @@ -2027,21 +2027,11 @@ static int pkcs7_hash2mgf(enum wc_HashType hType) case WC_HASH_TYPE_SHA3_512: case WC_HASH_TYPE_BLAKE2B: case WC_HASH_TYPE_BLAKE2S: -#ifndef WOLFSSL_NOSHA512_224 case WC_HASH_TYPE_SHA512_224: -#endif -#ifndef WOLFSSL_NOSHA512_256 case WC_HASH_TYPE_SHA512_256: -#endif -#ifdef WOLFSSL_SHAKE128 case WC_HASH_TYPE_SHAKE128: -#endif -#ifdef WOLFSSL_SHAKE256 case WC_HASH_TYPE_SHAKE256: -#endif -#ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: -#endif default: break; } diff --git a/wolfcrypt/src/rsa.c b/wolfcrypt/src/rsa.c index 914a5e3dd0..c31227240f 100644 --- a/wolfcrypt/src/rsa.c +++ b/wolfcrypt/src/rsa.c @@ -1991,27 +1991,17 @@ int wc_hash2mgf(enum wc_HashType hType) case WC_HASH_TYPE_MD4: case WC_HASH_TYPE_MD5: case WC_HASH_TYPE_MD5_SHA: - #ifndef WOLFSSL_NOSHA512_224 - case WC_HASH_TYPE_SHA512_224: - #endif - #ifndef WOLFSSL_NOSHA512_256 - case WC_HASH_TYPE_SHA512_256: - #endif + case WC_HASH_TYPE_SHA512_224: + case WC_HASH_TYPE_SHA512_256: case WC_HASH_TYPE_SHA3_224: case WC_HASH_TYPE_SHA3_256: case WC_HASH_TYPE_SHA3_384: case WC_HASH_TYPE_SHA3_512: case WC_HASH_TYPE_BLAKE2B: case WC_HASH_TYPE_BLAKE2S: -#ifdef WOLFSSL_SM3 case WC_HASH_TYPE_SM3: -#endif - #ifdef WOLFSSL_SHAKE128 - case WC_HASH_TYPE_SHAKE128: - #endif - #ifdef WOLFSSL_SHAKE256 - case WC_HASH_TYPE_SHAKE256: - #endif + case WC_HASH_TYPE_SHAKE128: + case WC_HASH_TYPE_SHAKE256: default: break; } diff --git a/wolfcrypt/test/test.c b/wolfcrypt/test/test.c index 6ee466ef02..2ffc7fac89 100644 --- a/wolfcrypt/test/test.c +++ b/wolfcrypt/test/test.c @@ -7599,11 +7599,22 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hash_test(void) #endif WC_HASH_TYPE_NONE }; - enum wc_HashType typesBad[] = { WC_HASH_TYPE_NONE, WC_HASH_TYPE_MD5_SHA, - WC_HASH_TYPE_MD2, WC_HASH_TYPE_MD4 }; - enum wc_HashType typesHashBad[] = { WC_HASH_TYPE_MD2, WC_HASH_TYPE_MD4, - WC_HASH_TYPE_BLAKE2B, - WC_HASH_TYPE_NONE }; + int typesBad[] = { WC_HASH_TYPE_NONE, WC_HASH_TYPE_MAX + 1 }; + + enum wc_HashType typesHashBad[] = { +#ifndef WOLFSSL_MD2 + WC_HASH_TYPE_MD2, +#endif +#ifdef NO_MD4 + WC_HASH_TYPE_MD4, +#endif +#if defined(NO_MD5) || defined(NO_SHA) + WC_HASH_TYPE_MD5_SHA, +#endif +#if !defined(HAVE_BLAKE2) && !defined(HAVE_BLAKE2S) + WC_HASH_TYPE_BLAKE2B, +#endif + WC_HASH_TYPE_NONE }; WOLFSSL_ENTER("hash_test"); @@ -7657,17 +7668,17 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hash_test(void) if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG)) { ERROR_OUT(WC_TEST_RET_ENC_I(i), out); } - ret = wc_HashInit(hash, typesBad[i]); + ret = wc_HashInit(hash, (enum wc_HashType)typesBad[i]); if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG)) ERROR_OUT(WC_TEST_RET_ENC_I(i), out); - ret = wc_HashUpdate(hash, typesBad[i], data, sizeof(data)); + ret = wc_HashUpdate(hash, (enum wc_HashType)typesBad[i], data, sizeof(data)); if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG)) ERROR_OUT(WC_TEST_RET_ENC_I(i), out); - ret = wc_HashFinal(hash, typesBad[i], out); + ret = wc_HashFinal(hash, (enum wc_HashType)typesBad[i], out); if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG)) ERROR_OUT(WC_TEST_RET_ENC_I(i), out); - ret = wc_HashFree(hash, typesBad[i]); + ret = wc_HashFree(hash, (enum wc_HashType)typesBad[i]); if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG)) ERROR_OUT(WC_TEST_RET_ENC_I(i), out); @@ -7804,7 +7815,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hash_test(void) #endif ret = wc_HashGetOID(WC_HASH_TYPE_MD5_SHA); -#ifndef NO_MD5 +#if !defined(NO_MD5) && !defined(NO_SHA) if (ret == WC_NO_ERR_TRACE(HASH_TYPE_E) || ret == WC_NO_ERR_TRACE(BAD_FUNC_ARG)) { @@ -7815,7 +7826,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hash_test(void) ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); #endif ret = wc_HashGetOID(WC_HASH_TYPE_MD4); - if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG)) + if (ret != WC_NO_ERR_TRACE(HASH_TYPE_E)) ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out); ret = wc_HashGetOID(WC_HASH_TYPE_NONE); if (ret != WC_NO_ERR_TRACE(BAD_FUNC_ARG)) diff --git a/wolfssl/wolfcrypt/types.h b/wolfssl/wolfcrypt/types.h index af7d6b6224..47a86c9e3a 100644 --- a/wolfssl/wolfcrypt/types.h +++ b/wolfssl/wolfcrypt/types.h @@ -1440,19 +1440,9 @@ enum wc_HashType { WC_HASH_TYPE_SHA3_512 = 13, WC_HASH_TYPE_BLAKE2B = 14, WC_HASH_TYPE_BLAKE2S = 19, -#ifdef WOLFSSL_SHAKE128 WC_HASH_TYPE_SHAKE128 = 20, -#endif -#ifdef WOLFSSL_SHAKE256 WC_HASH_TYPE_SHAKE256 = 21, -#endif -#if defined(WOLFSSL_SHAKE256) - WC_HASH_TYPE_MAX = WC_HASH_TYPE_SHAKE256, -#elif defined(WOLFSSL_SHAKE128) - WC_HASH_TYPE_MAX = WC_HASH_TYPE_SHAKE128, -#else - WC_HASH_TYPE_MAX = WC_HASH_TYPE_BLAKE2S, -#endif + WC_HASH_TYPE_MAX = WC_HASH_TYPE_SHAKE256 #ifndef WOLFSSL_NOSHA512_224 #define WOLFSSL_NOSHA512_224 #endif @@ -1476,34 +1466,12 @@ enum wc_HashType { WC_HASH_TYPE_SHA3_512 = 13, WC_HASH_TYPE_BLAKE2B = 14, WC_HASH_TYPE_BLAKE2S = 15, - #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_BLAKE2S - #ifndef WOLFSSL_NOSHA512_224 - WC_HASH_TYPE_SHA512_224 = 16, - #undef _WC_HASH_TYPE_MAX - #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHA512_224 - #endif - #ifndef WOLFSSL_NOSHA512_256 - WC_HASH_TYPE_SHA512_256 = 17, - #undef _WC_HASH_TYPE_MAX - #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHA512_256 - #endif - #ifdef WOLFSSL_SHAKE128 - WC_HASH_TYPE_SHAKE128 = 18, - #undef _WC_HASH_TYPE_MAX - #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHAKE128 - #endif - #ifdef WOLFSSL_SHAKE256 - WC_HASH_TYPE_SHAKE256 = 19, - #undef _WC_HASH_TYPE_MAX - #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SHAKE256 - #endif - #ifdef WOLFSSL_SM3 - WC_HASH_TYPE_SM3 = 20, - #undef _WC_HASH_TYPE_MAX - #define _WC_HASH_TYPE_MAX WC_HASH_TYPE_SM3 - #endif - WC_HASH_TYPE_MAX = _WC_HASH_TYPE_MAX - #undef _WC_HASH_TYPE_MAX + WC_HASH_TYPE_SHA512_224 = 16, + WC_HASH_TYPE_SHA512_256 = 17, + WC_HASH_TYPE_SHAKE128 = 18, + WC_HASH_TYPE_SHAKE256 = 19, + WC_HASH_TYPE_SM3 = 20, + WC_HASH_TYPE_MAX = WC_HASH_TYPE_SM3 #endif /* HAVE_SELFTEST */ };