diff --git a/tests/api/test_mldsa.c b/tests/api/test_mldsa.c index 9155bb6b928..6b6e41fac8b 100644 --- a/tests/api/test_mldsa.c +++ b/tests/api/test_mldsa.c @@ -4867,6 +4867,27 @@ int test_mldsa_make_key_from_seed(void) 0xF0, 0xC6, 0xF6, 0xAB, 0xDD, 0x2D, 0xBB, 0x29, 0x85, 0xFE, 0x26, 0x74, 0x82, 0x85, 0x8A, 0x1E }; + /* s2[4] of this seed needs a third SHAKE256 block: FIPS 204 Alg 31, 33. + * Expected bytes are its BitPack encoding, Alg 17 and 24. */ + static const byte seed_65_refill[32] = { 0x4F, 0x27 }; + static const byte s2_4_65_refill[] = { + 0x16, 0x13, 0x82, 0x83, 0x61, 0x52, 0x03, 0x61, + 0x62, 0x73, 0x58, 0x75, 0x53, 0x75, 0x50, 0x16, + 0x35, 0x07, 0x46, 0x40, 0x74, 0x88, 0x85, 0x24, + 0x12, 0x82, 0x87, 0x42, 0x47, 0x27, 0x13, 0x41, + 0x43, 0x33, 0x61, 0x37, 0x58, 0x11, 0x32, 0x65, + 0x28, 0x17, 0x07, 0x24, 0x60, 0x02, 0x22, 0x05, + 0x85, 0x15, 0x43, 0x71, 0x45, 0x46, 0x58, 0x57, + 0x12, 0x25, 0x35, 0x50, 0x03, 0x47, 0x88, 0x44, + 0x32, 0x67, 0x13, 0x22, 0x03, 0x53, 0x02, 0x24, + 0x72, 0x55, 0x43, 0x83, 0x45, 0x85, 0x87, 0x57, + 0x05, 0x62, 0x30, 0x60, 0x24, 0x78, 0x18, 0x16, + 0x28, 0x50, 0x50, 0x38, 0x88, 0x42, 0x65, 0x13, + 0x42, 0x48, 0x02, 0x82, 0x03, 0x37, 0x88, 0x15, + 0x18, 0x33, 0x85, 0x65, 0x35, 0x16, 0x22, 0x76, + 0x34, 0x66, 0x08, 0x18, 0x56, 0x82, 0x58, 0x75, + 0x50, 0x76, 0x44, 0x74, 0x48, 0x63, 0x16, 0x67 + }; #endif /* WOLFSSL_NO_ML_DSA_65 */ #ifndef WOLFSSL_NO_ML_DSA_87 static const byte seed_87[] = { @@ -8047,6 +8068,10 @@ int test_mldsa_make_key_from_seed(void) ExpectIntEQ(wc_MlDsaKey_MakeKeyFromSeed(key, seed_65), SEED_OK); ExpectIntEQ(XMEMCMP(key->p, pk_65, sizeof(pk_65)), 0); ExpectIntEQ(XMEMCMP(key->k, sk_65, sizeof(sk_65)), 0); + ExpectIntEQ(wc_MlDsaKey_MakeKeyFromSeed(key, seed_65_refill), SEED_OK); + /* rho, K, tr, then five 128-byte s1 and four s2 polys: Alg 24. */ + ExpectIntEQ(XMEMCMP(key->k + 32 + 32 + 64 + (5 + 4) * 128, + s2_4_65_refill, sizeof(s2_4_65_refill)), 0); #ifdef WOLFSSL_MLDSA_FIPS204_DRAFT ExpectIntEQ(wc_MlDsaKey_SetParams(key, WC_ML_DSA_65_DRAFT), 0); ExpectIntEQ(wc_MlDsaKey_MakeKeyFromSeed(key, seed_65_draft), SEED_OK); diff --git a/tests/api/test_sha256.c b/tests/api/test_sha256.c index bba029721d6..acba81dacbf 100644 --- a/tests/api/test_sha256.c +++ b/tests/api/test_sha256.c @@ -448,3 +448,28 @@ int test_wc_Sha224_Flags(void) return EXPECT_RESULT(); } +/* Final of a different variant than Init is refused. */ +int test_wc_Sha224_Sha256_MixedFinal(void) +{ + EXPECT_DECLS; +#if defined(WOLFSSL_SHA224) && !defined(NO_SHA256) && \ + defined(WC_HASH_CHECK_VARIANT) + wc_Sha256 sha; + byte hash[WC_SHA256_DIGEST_SIZE]; + + ExpectIntEQ(wc_InitSha224(&sha), 0); + ExpectIntEQ(wc_Sha224Update(&sha, (const byte*)"abc", 3), 0); + ExpectIntEQ(wc_Sha256Final(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); +#ifndef WOLFSSL_NO_HASH_RAW + ExpectIntEQ(wc_Sha256FinalRaw(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); +#endif + ExpectIntEQ(wc_Sha224Final(&sha, hash), 0); + wc_Sha224Free(&sha); + + ExpectIntEQ(wc_InitSha256(&sha), 0); + ExpectIntEQ(wc_Sha224Final(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Sha256Final(&sha, hash), 0); + wc_Sha256Free(&sha); +#endif + return EXPECT_RESULT(); +} diff --git a/tests/api/test_sha256.h b/tests/api/test_sha256.h index fbbfde365f1..3194ed11399 100644 --- a/tests/api/test_sha256.h +++ b/tests/api/test_sha256.h @@ -44,6 +44,7 @@ int test_wc_Sha224_other(void); int test_wc_Sha224Copy(void); int test_wc_Sha224GetHash(void); int test_wc_Sha224_Flags(void); +int test_wc_Sha224_Sha256_MixedFinal(void); #define TEST_SHA256_DECLS \ TEST_DECL_GROUP("sha256", test_wc_InitSha256), \ @@ -66,6 +67,7 @@ int test_wc_Sha224_Flags(void); TEST_DECL_GROUP("sha224", test_wc_Sha224_other), \ TEST_DECL_GROUP("sha224", test_wc_Sha224Copy), \ TEST_DECL_GROUP("sha224", test_wc_Sha224GetHash), \ - TEST_DECL_GROUP("sha224", test_wc_Sha224_Flags) + TEST_DECL_GROUP("sha224", test_wc_Sha224_Flags), \ + TEST_DECL_GROUP("sha224", test_wc_Sha224_Sha256_MixedFinal) #endif /* WOLFCRYPT_TEST_SHA256_H */ diff --git a/tests/api/test_sha3.c b/tests/api/test_sha3.c index ee49655de3e..b245f30d58a 100644 --- a/tests/api/test_sha3.c +++ b/tests/api/test_sha3.c @@ -927,6 +927,19 @@ int test_wc_Shake128_Absorb(void) ExpectIntEQ(wc_Shake128_Absorb(&shake128, NULL, 0), 0); #endif +#ifdef WC_HASH_CHECK_VARIANT + { + byte hash[1]; + /* Once absorbed, only SqueezeBlocks may follow until Init. */ + ExpectIntEQ(wc_Shake128_Absorb(&shake128, (byte*)"a", 1), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake128_Update(&shake128, (byte*)"a", 1), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake128_Final(&shake128, hash, sizeof(hash)), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_InitShake128(&shake128, HEAP_HINT, INVALID_DEVID), 0); + } +#endif ExpectIntEQ(wc_Shake128_Absorb(&shake128, (byte*)"a", 1), 0); @@ -952,6 +965,15 @@ int test_wc_Shake128_SqueezeBlocks(void) ExpectIntEQ(wc_Shake128_SqueezeBlocks(NULL , NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#ifdef WC_HASH_CHECK_VARIANT + /* Squeeze needs input padded by Absorb first. */ + ExpectIntEQ(wc_Shake128_SqueezeBlocks(&shake128, hash, 1), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake128_Update(&shake128, (byte*)"a", 1), 0); + ExpectIntEQ(wc_Shake128_SqueezeBlocks(&shake128, hash, 1), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake128_Absorb(&shake128, NULL, 0), 0); +#endif ExpectIntEQ(wc_Shake128_SqueezeBlocks(&shake128, NULL, 0), 0); #endif ExpectIntEQ(wc_Shake128_SqueezeBlocks(&shake128, hash, 1), 0); @@ -1351,6 +1373,19 @@ int test_wc_Shake256_Absorb(void) WC_NO_ERR_TRACE(BAD_FUNC_ARG)); ExpectIntEQ(wc_Shake256_Absorb(&shake256, NULL, 0), 0); +#endif +#ifdef WC_HASH_CHECK_VARIANT + { + byte hash[1]; + /* Once absorbed, only SqueezeBlocks may follow until Init. */ + ExpectIntEQ(wc_Shake256_Absorb(&shake256, (byte*)"a", 1), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake256_Update(&shake256, (byte*)"a", 1), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake256_Final(&shake256, hash, sizeof(hash)), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_InitShake256(&shake256, HEAP_HINT, INVALID_DEVID), 0); + } #endif ExpectIntEQ(wc_Shake256_Absorb(&shake256, (byte*)"a", 1), 0); @@ -1376,6 +1411,15 @@ int test_wc_Shake256_SqueezeBlocks(void) ExpectIntEQ(wc_Shake256_SqueezeBlocks(NULL , NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); +#ifdef WC_HASH_CHECK_VARIANT + /* Squeeze needs input padded by Absorb first. */ + ExpectIntEQ(wc_Shake256_SqueezeBlocks(&shake256, hash, 1), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake256_Update(&shake256, (byte*)"a", 1), 0); + ExpectIntEQ(wc_Shake256_SqueezeBlocks(&shake256, hash, 1), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake256_Absorb(&shake256, NULL, 0), 0); +#endif ExpectIntEQ(wc_Shake256_SqueezeBlocks(&shake256, NULL, 0), 0); #endif ExpectIntEQ(wc_Shake256_SqueezeBlocks(&shake256, hash, 1), 0); @@ -2606,3 +2650,96 @@ int test_wc_Cshake_Copy(void) #endif /* WOLFSSL_CSHAKE128 */ return EXPECT_RESULT(); } + +/* Update and Final at a different rate than the first call are refused. */ +int test_wc_Sha3_MixedRate(void) +{ + EXPECT_DECLS; +#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224) && \ + !defined(WOLFSSL_NOSHA3_512) && defined(WC_HASH_CHECK_VARIANT) + wc_Sha3 sha3; + byte hash[WC_SHA3_512_DIGEST_SIZE]; + + ExpectIntEQ(wc_InitSha3_224(&sha3, HEAP_HINT, INVALID_DEVID), 0); + ExpectIntEQ(wc_Sha3_224_Update(&sha3, (const byte*)"abc", 3), 0); + ExpectIntEQ(wc_Sha3_512_Update(&sha3, (const byte*)"abc", 3), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Sha3_512_Final(&sha3, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Sha3_224_Final(&sha3, hash), 0); + /* Final resets the state, so another variant may follow. */ + ExpectIntEQ(wc_Sha3_512_Final(&sha3, hash), 0); + wc_Sha3_224_Free(&sha3); +#ifdef WOLFSSL_SHAKE128 + ExpectIntEQ(wc_InitShake128(&sha3, HEAP_HINT, INVALID_DEVID), 0); + ExpectIntEQ(wc_Shake128_Update(&sha3, (const byte*)"abc", 3), 0); + ExpectIntEQ(wc_Sha3_224_Final(&sha3, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); + wc_Shake128_Free(&sha3); +#endif +#if defined(WOLFSSL_SHAKE128) && defined(WOLFSSL_SHAKE256) + { + /* SHAKE128("abc") and SHAKE256("abc"), 32 bytes: FIPS 202. */ + static const byte shake128Abc[] = { + 0x58, 0x81, 0x09, 0x2d, 0xd8, 0x18, 0xbf, 0x5c, + 0xf8, 0xa3, 0xdd, 0xb7, 0x93, 0xfb, 0xcb, 0xa7, + 0x40, 0x97, 0xd5, 0xc5, 0x26, 0xa6, 0xd3, 0x5f, + 0x97, 0xb8, 0x33, 0x51, 0x94, 0x0f, 0x2c, 0xc8 + }; + static const byte shake256Abc[] = { + 0x48, 0x33, 0x66, 0x60, 0x13, 0x60, 0xa8, 0x77, + 0x1c, 0x68, 0x63, 0x08, 0x0c, 0xc4, 0x11, 0x4d, + 0x8d, 0xb4, 0x45, 0x30, 0xf8, 0xf1, 0xe1, 0xee, + 0x4f, 0x94, 0xea, 0x37, 0xe7, 0x8b, 0x57, 0x39 + }; + + /* A refused Absorb keeps the input already buffered. */ + ExpectIntEQ(wc_InitShake256(&sha3, HEAP_HINT, INVALID_DEVID), 0); + ExpectIntEQ(wc_Shake256_Update(&sha3, (const byte*)"abc", 3), 0); + ExpectIntEQ(wc_Shake128_Absorb(&sha3, (const byte*)"abc", 3), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake256_Final(&sha3, hash, sizeof(shake256Abc)), 0); + ExpectBufEQ(hash, shake256Abc, sizeof(shake256Abc)); + wc_Shake256_Free(&sha3); + + ExpectIntEQ(wc_InitShake128(&sha3, HEAP_HINT, INVALID_DEVID), 0); + ExpectIntEQ(wc_Shake128_Update(&sha3, (const byte*)"abc", 3), 0); + ExpectIntEQ(wc_Shake256_Absorb(&sha3, (const byte*)"abc", 3), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake128_Final(&sha3, hash, sizeof(shake128Abc)), 0); + ExpectBufEQ(hash, shake128Abc, sizeof(shake128Abc)); + wc_Shake128_Free(&sha3); + #ifndef WOLFSSL_NOSHA3_256 + { + /* SHA3-256("abc"): FIPS 202. Same rate as SHAKE256. */ + static const byte sha3_256Abc[] = { + 0x3a, 0x98, 0x5d, 0xa7, 0x4f, 0xe2, 0x25, 0xb2, + 0x04, 0x5c, 0x17, 0x2d, 0x6b, 0xd3, 0x90, 0xbd, + 0x85, 0x5f, 0x08, 0x6e, 0x3e, 0x9d, 0x52, 0x5b, + 0x46, 0xbf, 0xe2, 0x45, 0x11, 0x43, 0x15, 0x32 + }; + + ExpectIntEQ(wc_InitSha3_256(&sha3, HEAP_HINT, INVALID_DEVID), 0); + ExpectIntEQ(wc_Sha3_256_Update(&sha3, (const byte*)"abc", 3), 0); + ExpectIntEQ(wc_Shake256_Update(&sha3, (const byte*)"abc", 3), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake256_Final(&sha3, hash, sizeof(shake256Abc)), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Sha3_256_Final(&sha3, hash), 0); + ExpectBufEQ(hash, sha3_256Abc, sizeof(sha3_256Abc)); + wc_Sha3_256_Free(&sha3); + + ExpectIntEQ(wc_InitShake256(&sha3, HEAP_HINT, INVALID_DEVID), 0); + ExpectIntEQ(wc_Shake256_Update(&sha3, (const byte*)"abc", 3), 0); + ExpectIntEQ(wc_Sha3_256_Update(&sha3, (const byte*)"abc", 3), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Sha3_256_Final(&sha3, hash), + WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Shake256_Final(&sha3, hash, sizeof(shake256Abc)), 0); + ExpectBufEQ(hash, shake256Abc, sizeof(shake256Abc)); + wc_Shake256_Free(&sha3); + } + #endif + } +#endif +#endif + return EXPECT_RESULT(); +} diff --git a/tests/api/test_sha3.h b/tests/api/test_sha3.h index 5fddb479df1..4e8c313025f 100644 --- a/tests/api/test_sha3.h +++ b/tests/api/test_sha3.h @@ -69,6 +69,7 @@ int test_wc_Kmac_Copy(void); int test_wc_Cshake128(void); int test_wc_Cshake256(void); int test_wc_Cshake_Copy(void); +int test_wc_Sha3_MixedRate(void); #define TEST_SHA3_DECLS \ TEST_DECL_GROUP("sha3", test_wc_InitSha3), \ @@ -81,7 +82,8 @@ int test_wc_Cshake_Copy(void); TEST_DECL_GROUP("sha3", test_wc_Sha3_other), \ TEST_DECL_GROUP("sha3", test_wc_Sha3_Copy), \ TEST_DECL_GROUP("sha3", test_wc_Sha3_GetHash), \ - TEST_DECL_GROUP("sha3", test_wc_Sha3_Flags) + TEST_DECL_GROUP("sha3", test_wc_Sha3_Flags), \ + TEST_DECL_GROUP("sha3", test_wc_Sha3_MixedRate) #define TEST_SHAKE128_DECLS \ TEST_DECL_GROUP("shake128", test_wc_InitShake128), \ diff --git a/tests/api/test_sha512.c b/tests/api/test_sha512.c index 17bb329f392..6493b74c7d0 100644 --- a/tests/api/test_sha512.c +++ b/tests/api/test_sha512.c @@ -1201,3 +1201,47 @@ int test_wc_sha512_cryptocb_free(void) return EXPECT_RESULT(); } +/* Final of a different variant than Init is refused. */ +int test_wc_Sha512_Family_MixedFinal(void) +{ + EXPECT_DECLS; +#if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384) && \ + defined(WC_HASH_CHECK_VARIANT) + wc_Sha512 sha; + byte hash[WC_SHA512_DIGEST_SIZE]; + + ExpectIntEQ(wc_InitSha384(&sha), 0); + ExpectIntEQ(wc_Sha384Update(&sha, (const byte*)"abc", 3), 0); + ExpectIntEQ(wc_Sha512Final(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); +#ifndef WOLFSSL_NO_HASH_RAW + ExpectIntEQ(wc_Sha512FinalRaw(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); +#endif + ExpectIntEQ(wc_Sha384Final(&sha, hash), 0); + wc_Sha384Free(&sha); + + ExpectIntEQ(wc_InitSha512(&sha), 0); + ExpectIntEQ(wc_Sha384Final(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); +#ifndef WOLFSSL_NO_HASH_RAW + ExpectIntEQ(wc_Sha384FinalRaw(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); +#endif +#ifdef TEST_WC_SHA512_224_FALLBACK + ExpectIntEQ(wc_Sha512_224Final(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); +#endif + ExpectIntEQ(wc_Sha512Final(&sha, hash), 0); + wc_Sha512Free(&sha); + +#if defined(TEST_WC_SHA512_224_FALLBACK) && defined(TEST_WC_SHA512_256_FALLBACK) + ExpectIntEQ(wc_InitSha512_224(&sha), 0); + ExpectIntEQ(wc_Sha512_256Final(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Sha512Final(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Sha512_224Final(&sha, hash), 0); + wc_Sha512_224Free(&sha); + + ExpectIntEQ(wc_InitSha512_256(&sha), 0); + ExpectIntEQ(wc_Sha384Final(&sha, hash), WC_NO_ERR_TRACE(BAD_STATE_E)); + ExpectIntEQ(wc_Sha512_256Final(&sha, hash), 0); + wc_Sha512_256Free(&sha); +#endif +#endif + return EXPECT_RESULT(); +} diff --git a/tests/api/test_sha512.h b/tests/api/test_sha512.h index 33474244558..c254a60e1c0 100644 --- a/tests/api/test_sha512.h +++ b/tests/api/test_sha512.h @@ -66,6 +66,7 @@ int test_wc_Sha384_other(void); int test_wc_Sha384Copy(void); int test_wc_Sha384GetHash(void); int test_wc_Sha384_Flags(void); +int test_wc_Sha512_Family_MixedFinal(void); int test_wc_sha512_cryptocb_fallback(void); int test_wc_sha512_variants_default_devid(void); int test_wc_sha512_cryptocb_free(void); @@ -118,6 +119,7 @@ int test_wc_sha512_cryptocb_free(void); TEST_DECL_GROUP("sha384", test_wc_Sha384_other), \ TEST_DECL_GROUP("sha384", test_wc_Sha384Copy), \ TEST_DECL_GROUP("sha384", test_wc_Sha384GetHash), \ - TEST_DECL_GROUP("sha384", test_wc_Sha384_Flags) + TEST_DECL_GROUP("sha384", test_wc_Sha384_Flags), \ + TEST_DECL_GROUP("sha384", test_wc_Sha512_Family_MixedFinal) #endif /* WOLFCRYPT_TEST_SHA512_H */ diff --git a/wolfcrypt/src/sha256.c b/wolfcrypt/src/sha256.c index 3811aa4b45d..1abea88cbde 100644 --- a/wolfcrypt/src/sha256.c +++ b/wolfcrypt/src/sha256.c @@ -330,6 +330,9 @@ static int InitSha256(wc_Sha256* sha256) sha256->len = 0; sha256->used = 0; #endif +#ifdef WC_HASH_CHECK_VARIANT + sha256->digestSz = WC_SHA256_DIGEST_SIZE; +#endif #if (defined(WOLFSSL_X86_64_BUILD) && defined(USE_INTEL_SPEEDUP) && \ (defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2))) || \ @@ -2524,6 +2527,11 @@ static WC_INLINE int Transform_Sha256_Len(wc_Sha256* sha256, const byte* data, if (sha256 == NULL || hash == NULL) { return BAD_FUNC_ARG; } + #ifdef WC_HASH_CHECK_VARIANT + if (sha256->digestSz != WC_SHA256_DIGEST_SIZE) { + return BAD_STATE_E; + } + #endif #if defined(WOLFSSL_CHECK_MEM_ZERO) && defined(LITTLE_ENDIAN_ORDER) && \ !defined(WOLFSSL_WIDE_BYTE) wc_MemZero_Add("wc_Sha256FinalRaw digest", digest, sizeof(digest)); @@ -2557,6 +2565,11 @@ static WC_INLINE int Transform_Sha256_Len(wc_Sha256* sha256, const byte* data, if (sha256 == NULL || hash == NULL) { return BAD_FUNC_ARG; } + #ifdef WC_HASH_CHECK_VARIANT + if (sha256->digestSz != WC_SHA256_DIGEST_SIZE) { + return BAD_STATE_E; + } + #endif #ifdef WOLF_CRYPTO_CB #ifndef WOLF_CRYPTO_CB_FIND @@ -2995,6 +3008,9 @@ static WC_INLINE int Transform_Sha256_Len(wc_Sha256* sha256, const byte* data, XMEMSET(sha224->buffer, 0, sizeof(sha224->buffer)); sha224->loLen = 0; sha224->hiLen = 0; + #ifdef WC_HASH_CHECK_VARIANT + sha224->digestSz = WC_SHA224_DIGEST_SIZE; + #endif #if defined(WOLFSSL_X86_64_BUILD) && defined(USE_INTEL_SPEEDUP) && \ (defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)) @@ -3180,6 +3196,11 @@ int wc_Sha224Reset(wc_Sha224* sha224) { if (sha224 == NULL || hash == NULL) { return BAD_FUNC_ARG; } + #ifdef WC_HASH_CHECK_VARIANT + if (sha224->digestSz != WC_SHA224_DIGEST_SIZE) { + return BAD_STATE_E; + } + #endif #ifdef WOLF_CRYPTO_CB #ifndef WOLF_CRYPTO_CB_FIND if (sha224->devId != INVALID_DEVID) diff --git a/wolfcrypt/src/sha3.c b/wolfcrypt/src/sha3.c index f951011ed18..65d3b6040e8 100644 --- a/wolfcrypt/src/sha3.c +++ b/wolfcrypt/src/sha3.c @@ -930,6 +930,11 @@ static int InitSha3(wc_Sha3* sha3) #ifdef WOLFSSL_HASH_FLAGS sha3->flags = 0; #endif +#ifdef WC_HASH_CHECK_VARIANT + sha3->count = 0; + sha3->absorbed = 0; + sha3->pad = 0; +#endif #ifdef WOLF_CRYPTO_CB /* Cached hash variant is tied to sponge state; clear it whenever the * state is reset so reuse for a different SHA3 variant dispatches @@ -1016,6 +1021,41 @@ void BlockSha3(word64* s) } #endif +#ifdef WC_HASH_CHECK_VARIANT +/* Keep one block count from Init to Final: FIPS 202 6.1, 6.2 fix the rate. + * No input once Absorb has padded it: FIPS 202 Algorithm 8. */ +static int Sha3CheckState(wc_Sha3* sha3, word32 p) +{ + if (sha3->absorbed || ((sha3->count != 0) && (sha3->count != p))) { + return BAD_STATE_E; + } + sha3->count = p; + return 0; +} + +/* SHA3-256 and SHAKE256 share a rate, so keep one domain too: FIPS 202 6.1, + * 6.2. */ +static int Sha3CheckDomain(wc_Sha3* sha3, byte pad) +{ + if ((sha3->pad != 0) && (sha3->pad != pad)) { + return BAD_STATE_E; + } + sha3->pad = pad; + return 0; +} + +#if defined(WOLFSSL_SHAKE128) || defined(WOLFSSL_SHAKE256) +/* Squeeze only from input padded by Absorb at the same rate. */ +static int Sha3CheckSqueeze(const wc_Sha3* sha3, word32 p) +{ + if (!sha3->absorbed || (sha3->count != p)) { + return BAD_STATE_E; + } + return 0; +} +#endif +#endif + /* Update the SHA-3 hash state with message data. * * sha3 wc_Sha3 object holding state. @@ -1044,6 +1084,11 @@ static int Sha3Update(wc_Sha3* sha3, const byte* data, word32 len, word32 p) if ((p < WC_SHA3_512_COUNT) || (p > WC_SHA3_128_COUNT)) return BAD_STATE_E; +#ifdef WC_HASH_CHECK_VARIANT + ret = Sha3CheckState(sha3, p); + if (ret != 0) + return ret; +#endif blockSz = p * 8U; @@ -1223,6 +1268,10 @@ static int Sha3Final(wc_Sha3* sha3, byte padChar, byte* hash, word32 p, word32 l return BAD_STATE_E; if (sha3->i >= rate) return BAD_STATE_E; +#ifdef WC_HASH_CHECK_VARIANT + if ((Sha3CheckState(sha3, p) != 0) || (Sha3CheckDomain(sha3, padChar) != 0)) + return BAD_STATE_E; +#endif #if defined(USE_INTEL_SPEEDUP) || defined(SHA3_NEEDS_VREG_CLAIM) if (SHA3_BLOCK_VREGS(sha3_block)) { @@ -1581,6 +1630,10 @@ static int wc_Sha3Update(wc_Sha3* sha3, const byte* data, word32 len, word32 p) } #endif /* WOLFSSL_ASYNC_CRYPT */ +#ifdef WC_HASH_CHECK_VARIANT + if (Sha3CheckDomain(sha3, 0x06) != 0) + return BAD_STATE_E; +#endif ret = Sha3Update(sha3, data, len, p); return ret; @@ -1664,6 +1717,11 @@ static void wc_Sha3Wipe(wc_Sha3* sha3) ForceZero(&sha3->stmCtx, sizeof(sha3->stmCtx)); #endif sha3->i = 0; +#ifdef WC_HASH_CHECK_VARIANT + sha3->count = 0; + sha3->absorbed = 0; + sha3->pad = 0; +#endif #endif } @@ -2345,6 +2403,10 @@ int wc_Shake128_Update(wc_Shake* shake, const byte* data, word32 len) } #endif +#ifdef WC_HASH_CHECK_VARIANT + if (Sha3CheckDomain(shake, 0x1f) != 0) + return BAD_STATE_E; +#endif return Sha3Update(shake, data, len, WC_SHA3_128_COUNT); } @@ -2419,13 +2481,23 @@ int wc_Shake128_Absorb(wc_Shake* shake, const byte* data, word32 len) } #endif +#ifdef WC_HASH_CHECK_VARIANT + if (Sha3CheckDomain(shake, 0x1f) != 0) + return BAD_STATE_E; +#endif ret = Sha3Update(shake, data, len, WC_SHA3_128_COUNT); if (ret == 0) { byte hash[1]; ret = Sha3Final(shake, 0x1f, hash, WC_SHA3_128_COUNT, 0); } - /* No partial data. */ - shake->i = 0; + /* A refused call leaves buffered input in place. */ + if (ret == 0) { + #ifdef WC_HASH_CHECK_VARIANT + shake->absorbed = 1; + #endif + /* No partial data. */ + shake->i = 0; + } return ret; } @@ -2469,6 +2541,11 @@ int wc_Shake128_SqueezeBlocks(wc_Shake* shake, byte* out, word32 blockCnt) /* fall-through when unavailable */ } #endif +#ifdef WC_HASH_CHECK_VARIANT + if (Sha3CheckSqueeze(shake, WC_SHA3_128_COUNT) != 0) { + return BAD_STATE_E; + } +#endif #if defined(USE_INTEL_SPEEDUP) || defined(SHA3_NEEDS_VREG_CLAIM) #if defined(USE_INTEL_SPEEDUP) && defined(WC_C_DYNAMIC_FALLBACK) @@ -2697,6 +2774,10 @@ int wc_Shake256_Update(wc_Shake* shake, const byte* data, word32 len) } #endif +#ifdef WC_HASH_CHECK_VARIANT + if (Sha3CheckDomain(shake, 0x1f) != 0) + return BAD_STATE_E; +#endif return Sha3Update(shake, data, len, WC_SHA3_256_COUNT); } @@ -2772,13 +2853,23 @@ int wc_Shake256_Absorb(wc_Shake* shake, const byte* data, word32 len) } #endif +#ifdef WC_HASH_CHECK_VARIANT + if (Sha3CheckDomain(shake, 0x1f) != 0) + return BAD_STATE_E; +#endif ret = Sha3Update(shake, data, len, WC_SHA3_256_COUNT); if (ret == 0) { byte hash[1]; ret = Sha3Final(shake, 0x1f, hash, WC_SHA3_256_COUNT, 0); } - /* No partial data. */ - shake->i = 0; + /* A refused call leaves buffered input in place. */ + if (ret == 0) { + #ifdef WC_HASH_CHECK_VARIANT + shake->absorbed = 1; + #endif + /* No partial data. */ + shake->i = 0; + } return ret; } @@ -2815,6 +2906,11 @@ int wc_Shake256_SqueezeBlocks(wc_Shake* shake, byte* out, word32 blockCnt) /* fall-through when unavailable */ } #endif +#ifdef WC_HASH_CHECK_VARIANT + if (Sha3CheckSqueeze(shake, WC_SHA3_256_COUNT) != 0) { + return BAD_STATE_E; + } +#endif #if defined(USE_INTEL_SPEEDUP) || defined(SHA3_NEEDS_VREG_CLAIM) #if defined(USE_INTEL_SPEEDUP) && defined(WC_C_DYNAMIC_FALLBACK) diff --git a/wolfcrypt/src/sha512.c b/wolfcrypt/src/sha512.c index c66309eb8ce..b29454fccb3 100644 --- a/wolfcrypt/src/sha512.c +++ b/wolfcrypt/src/sha512.c @@ -1000,6 +1000,9 @@ static int InitSha512(wc_Sha512* sha512) XMEMSET(sha512->buffer, 0, sizeof(sha512->buffer)); sha512->loLen = 0; sha512->hiLen = 0; +#ifdef WC_HASH_CHECK_VARIANT + sha512->digestSz = WC_SHA512_DIGEST_SIZE; +#endif #if (defined(WOLFSSL_X86_64_BUILD) && defined(USE_INTEL_SPEEDUP) && \ (defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2))) || \ @@ -1088,6 +1091,9 @@ static int InitSha512_224(wc_Sha512* sha512) XMEMSET(sha512->buffer, 0, sizeof(sha512->buffer)); sha512->loLen = 0; sha512->hiLen = 0; +#ifdef WC_HASH_CHECK_VARIANT + sha512->digestSz = WC_SHA512_224_DIGEST_SIZE; +#endif #if (defined(WOLFSSL_X86_64_BUILD) && defined(USE_INTEL_SPEEDUP) && \ (defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2))) || \ @@ -1163,6 +1169,9 @@ static int InitSha512_256(wc_Sha512* sha512) XMEMSET(sha512->buffer, 0, sizeof(sha512->buffer)); sha512->loLen = 0; sha512->hiLen = 0; +#ifdef WC_HASH_CHECK_VARIANT + sha512->digestSz = WC_SHA512_256_DIGEST_SIZE; +#endif #if (defined(WOLFSSL_X86_64_BUILD) && defined(USE_INTEL_SPEEDUP) && \ (defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2))) || \ @@ -2718,6 +2727,11 @@ static int Sha512FinalRaw(wc_Sha512* sha512, byte* hash, word32 digestSz) if (sha512 == NULL || hash == NULL) { return BAD_FUNC_ARG; } +#ifdef WC_HASH_CHECK_VARIANT + if (sha512->digestSz != digestSz) { + return BAD_STATE_E; + } +#endif #if defined(WOLFSSL_WIDE_BYTE) BytesFromWordsBE64(hash, sha512->digest, digestSz); @@ -2758,6 +2772,11 @@ static int Sha512_Family_Final(wc_Sha512* sha512, byte* hash, size_t digestSz, if (sha512 == NULL || hash == NULL) { return BAD_FUNC_ARG; } +#ifdef WC_HASH_CHECK_VARIANT + if (sha512->digestSz != digestSz) { + return BAD_STATE_E; + } +#endif #ifdef WOLF_CRYPTO_CB #ifndef WOLF_CRYPTO_CB_FIND @@ -3121,6 +3140,9 @@ static int InitSha384(wc_Sha384* sha384) XMEMSET(sha384->buffer, 0, sizeof(sha384->buffer)); sha384->loLen = 0; sha384->hiLen = 0; +#ifdef WC_HASH_CHECK_VARIANT + sha384->digestSz = WC_SHA384_DIGEST_SIZE; +#endif #if (defined(WOLFSSL_X86_64_BUILD) && defined(USE_INTEL_SPEEDUP) && \ (defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2))) || \ @@ -3225,6 +3247,11 @@ int wc_Sha384FinalRaw(wc_Sha384* sha384, byte* hash) if (sha384 == NULL || hash == NULL) { return BAD_FUNC_ARG; } +#ifdef WC_HASH_CHECK_VARIANT + if (sha384->digestSz != WC_SHA384_DIGEST_SIZE) { + return BAD_STATE_E; + } +#endif #if defined(WOLFSSL_WIDE_BYTE) BytesFromWordsBE64(hash, sha384->digest, WC_SHA384_DIGEST_SIZE); @@ -3244,6 +3271,11 @@ int wc_Sha384Final(wc_Sha384* sha384, byte* hash) if (sha384 == NULL || hash == NULL) { return BAD_FUNC_ARG; } +#ifdef WC_HASH_CHECK_VARIANT + if (sha384->digestSz != WC_SHA384_DIGEST_SIZE) { + return BAD_STATE_E; + } +#endif #ifdef WOLF_CRYPTO_CB #ifndef WOLF_CRYPTO_CB_FIND diff --git a/wolfcrypt/src/wc_mldsa.c b/wolfcrypt/src/wc_mldsa.c index 16704cc8e88..9ea538bef5b 100644 --- a/wolfcrypt/src/wc_mldsa.c +++ b/wolfcrypt/src/wc_mldsa.c @@ -1699,6 +1699,12 @@ static int mldsa_squeeze256(wc_Shake* shake256, const byte* in, ret = wc_Shake256_SqueezeBlocks(shake256, out, outBlocks); } #endif +#if defined(WC_HASH_CHECK_VARIANT) && \ + (defined(USE_INTEL_SPEEDUP) || defined(MLDSA_SHAKE_DIRECT)) + /* State above is absorbed at the SHAKE256 rate, so a refill may squeeze. */ + shake256->count = WC_SHA3_256_COUNT; + shake256->absorbed = 1; +#endif return ret; } diff --git a/wolfssl/wolfcrypt/settings.h b/wolfssl/wolfcrypt/settings.h index 638d0e730e2..ed6e01a613e 100644 --- a/wolfssl/wolfcrypt/settings.h +++ b/wolfssl/wolfcrypt/settings.h @@ -4139,6 +4139,12 @@ #define WOLFSSL_FIPS_EXPORT_LOCAL_APIS #endif +/* FIPS v7: a hash state remembers its variant and refuses another one. */ +#if defined(HAVE_FIPS) && FIPS_VERSION3_GE(7,0,0) + #undef WC_HASH_CHECK_VARIANT + #define WC_HASH_CHECK_VARIANT +#endif + /* Default AES minimum auth tag sz, allow user to override */ #ifndef WOLFSSL_MIN_AUTH_TAG_SZ #define WOLFSSL_MIN_AUTH_TAG_SZ 12 diff --git a/wolfssl/wolfcrypt/sha256.h b/wolfssl/wolfcrypt/sha256.h index c3190d32d07..3f3d79eb9ae 100644 --- a/wolfssl/wolfcrypt/sha256.h +++ b/wolfssl/wolfcrypt/sha256.h @@ -303,6 +303,9 @@ struct wc_Sha256 { #ifdef WOLFSSL_HASH_FLAGS word32 flags; /* enum wc_HashFlags in hash.h */ #endif +#ifdef WC_HASH_CHECK_VARIANT + word32 digestSz; /* digest size of the variant set by Init */ +#endif }; #ifndef WC_SHA256_TYPE_DEFINED diff --git a/wolfssl/wolfcrypt/sha3.h b/wolfssl/wolfcrypt/sha3.h index da56771723a..0de58fa74ba 100644 --- a/wolfssl/wolfcrypt/sha3.h +++ b/wolfssl/wolfcrypt/sha3.h @@ -175,6 +175,11 @@ struct wc_Sha3 { #ifdef WOLFSSL_HASH_FLAGS word32 flags; /* enum wc_HashFlags in hash.h */ #endif +#ifdef WC_HASH_CHECK_VARIANT + word32 count; /* block count of the first Update or Final, 0 after Init */ + byte absorbed; /* set by Absorb: only SqueezeBlocks may follow */ + byte pad; /* domain of the first call: 0x06 SHA-3, 0x1f SHAKE */ +#endif #if defined(STM32_HASH_SHA3) STM32_HASH_Context stmCtx; #endif diff --git a/wolfssl/wolfcrypt/sha512.h b/wolfssl/wolfcrypt/sha512.h index ad7eef309ea..f6fe1fbc606 100644 --- a/wolfssl/wolfcrypt/sha512.h +++ b/wolfssl/wolfcrypt/sha512.h @@ -221,6 +221,9 @@ struct wc_Sha512 { #if defined(WOLFSSL_SHA512_HASHTYPE) int hashType; /* used to determine which SHA512 is used */ #endif /* WOLFSSL_SHA512_HASHTYPE */ +#ifdef WC_HASH_CHECK_VARIANT + word32 digestSz; /* digest size of the variant set by Init */ +#endif #endif /* WOLFSSL_PSOC6_CRYPTO */ };