1 files changed, 27 insertions, 39 deletions
diff --git a/src/Common/Tests.c b/src/Common/Tests.c
index 530e7577..8f851f62 100644
--- a/src/Common/Tests.c
+++ b/src/Common/Tests.c
@@ -540,145 +540,134 @@ typedef struct _HashTestVector
 	const char* hexOutput;
 
 } HashTestVector;
 
 typedef int (__cdecl HashFunction) (unsigned char* input, unsigned long inputLen, unsigned char* output);
 
 unsigned char HexCharToByte (char c)
 {
    if (c >= ('0') && c <= ('9'))
       return c - ('0');
    else if (c >= ('A') && c <= ('F'))
       return c - ('A') + 10;
    else if (c >= ('a') && c <= ('f'))
       return c - ('a') + 10;
    else
       return 0xFF;
 }
 
 unsigned long HexStringToByteArray(const char* hexStr, unsigned char* pbData)
 {
 	unsigned long count = 0;
 	while (*hexStr)
 	{
 		*pbData++ = (HexCharToByte(hexStr[0]) << 4) | HexCharToByte(hexStr[1]);
 		hexStr += 2;
 		count++;
 	}
 	return count;
 }
 
-BOOL RunHashTest (HashFunction fn, HashTestVector* vector, BOOL bUseSSE)
+BOOL RunHashTest (HashFunction fn, HashTestVector* vector)
 {
 	CRYPTOPP_ALIGN_DATA (16) unsigned char input[256];
 	unsigned char output[64];
 	unsigned char digest[64];
 	unsigned long i = 0, inputLen, outputLen, digestLen;
 	BOOL bRet = TRUE;
-#if defined (DEVICE_DRIVER) && !defined (_WIN64)
-	KFLOATING_SAVE floatingPointState;
-	NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;
-	if (bUseSSE)
-		saveStatus = KeSaveFloatingPointState (&floatingPointState);
-#endif
 	while (vector[i].hexInput && vector[i].hexOutput)
 	{
 		inputLen = HexStringToByteArray (vector[i].hexInput, input);
 		outputLen = HexStringToByteArray (vector[i].hexOutput, output);
 		digestLen = fn (input, inputLen, digest);
 		if ((digestLen != outputLen) || (0 != memcmp (digest, output, digestLen)))
 		{
 			bRet = FALSE;
 			break;
 		}
 		i++;
 	}
 
-#if defined (DEVICE_DRIVER) && !defined (_WIN64)
-	if (NT_SUCCESS (saveStatus))
-		KeRestoreFloatingPointState (&floatingPointState);
-#endif
-
 	return bRet;
 }
 
 
 /* https://www.streebog.net/src/trunk/examples/ */
 HashTestVector Streebog512TestVectors[] = {
 	/* M1 */
 	{"303132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930313233343536373839303132", 
 	 "1b54d01a4af5b9d5cc3d86d68d285462b19abc2475222f35c085122be4ba1ffa00ad30f8767b3a82384c6574f024c311e2a481332b08ef7f41797891c1646f48"
 	},
 	/* M2 */
 	{"d1e520e2e5f2f0e82c20d1f2f0e8e1eee6e820e2edf3f6e82c20e2e5fef2fa20f120eceef0ff20f1f2f0e5ebe0ece820ede020f5f0e0e1f0fbff20efebfaeafb20c8e3eef0e5e2fb",
 	"1e88e62226bfca6f9994f1f2d51569e0daf8475a3b0fe61a5300eee46d961376035fe83549ada2b8620fcd7c496ce5b33f0cb9dddc2b6460143b03dabac9fb28"
 	},
 	/* M3 */
 	{"",
 	"8e945da209aa869f0455928529bcae4679e9873ab707b55315f56ceb98bef0a7362f715528356ee83cda5f2aac4c6ad2ba3a715c1bcd81cb8e9f90bf4c1c1a8a"
 	},
 	/* M4 */
 	{"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
 	"b0fd29ac1b0df441769ff3fdb8dc564df67721d6ac06fb28ceffb7bbaa7948c6c014ac999235b58cb26fb60fb112a145d7b4ade9ae566bf2611402c552d20db7"
 	},
 	{NULL, NULL}
 };
 
 /* https://github.com/openssl/openssl/blob/2d0b44126763f989a4cbffbffe9d0c7518158bb7/test/evptests.txt */
 HashTestVector Blake2sTestVectors[] = {
 	{"", 
 	 "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9"
 	},
 	{"61",
 	"4a0d129873403037c2cd9b9048203687f6233fb6738956e0349bd4320fec3e90"
 	},
 	{"616263",
 	"508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982"
 	},
 	{"6d65737361676520646967657374",
 	"fa10ab775acf89b7d3c8a6e823d586f6b67bdbac4ce207fe145b7d3ac25cd28c"
 	},
 	{"6162636465666768696a6b6c6d6e6f707172737475767778797a",
 	"bdf88eb1f86a0cdf0e840ba88fa118508369df186c7355b4b16cf79fa2710a12"
 	},
 	{"4142434445464748494a4b4c4d4e4f505152535455565758595a6162636465666768696a6b6c6d6e6f707172737475767778797a30313233343536373839",
 	"c75439ea17e1de6fa4510c335dc3d3f343e6f9e1ce2773e25b4174f1df8b119b"
 	},
 	{"3132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930",
 	"fdaedb290a0d5af9870864fec2e090200989dc9cd53a3c092129e8535e8b4f66"
 	},
 	{NULL, NULL}
 };
 
 unsigned char ks_tmp[MAX_EXPANDED_KEY];
 
-void CipherInit2(int cipher, void* key, void* ks, int key_len)
+void CipherInit2(int cipher, void* key, void* ks)
 {
 	switch (cipher)
 	{
 
 	case AES:
 		CipherInit(cipher,key,ks);
 		break;
 
 	case SERPENT:
 		CipherInit(cipher,key,ks);
 		break;
 
 	case TWOFISH:
 		CipherInit(cipher,key,ks);
 		break;
 		
 	case CAMELLIA:
 		CipherInit(cipher,key,ks);
 		break;
 	case KUZNYECHIK:
 		CipherInit(cipher, key, ks);
 		break;
 	default:
 		/* Unknown/wrong ID */
 		TC_THROW_FATAL_EXCEPTION;
 	}
 }
 
 
 BOOL TestSectorBufEncryption (PCRYPTO_INFO ci)
@@ -1280,96 +1269,95 @@ BOOL TestSectorBufEncryption (PCRYPTO_INFO ci)
 		}
 		else if (wcscmp (name, L"Kuznyechik-AES") == 0)
 		{
 			if (crc != 0x4641234a)
 				return FALSE;
 			nTestsPerformed++;
 		}
 		else if (wcscmp (name, L"Kuznyechik-Serpent-Camellia") == 0)
 		{
 			if (crc != 0x755dad72)
 				return FALSE;
 			nTestsPerformed++;
 		}
         #endif
 		if (crc == 0x9f5edd58)
 			return FALSE;
 
 		DecryptBuffer (buf, sizeof (buf), ci);
 
 		if (GetCrc32 (buf, sizeof (buf)) != 0x9f5edd58)
 			return FALSE;
 
 		nTestsPerformed++;
 	}
 	return (nTestsPerformed == 150);
 }
 
 static BOOL DoAutoTestAlgorithms (void)
 {
 	PCRYPTO_INFO ci;
-	CRYPTOPP_ALIGN_DATA(16) char key[32];
+	CRYPTOPP_ALIGN_DATA(16) unsigned char key[32];
 	unsigned char tmp[16];
 	BOOL bFailed = FALSE;
 	int i;
 
 	ci = crypto_open ();
 	if (!ci)
 		return FALSE;
 
 	memset (ci, 0, sizeof (*ci));
 
 	/* AES */
 
 	for (i = 0; i < AES_TEST_COUNT; i++)
 	{
 		int cipher = AES;
 		memcpy(key, aes_ecb_vectors[i].key, 32);
 		memcpy(tmp, aes_ecb_vectors[i].plaintext, 16);
 		CipherInit(cipher, key, ks_tmp);
 
 		EncipherBlock(cipher, tmp, ks_tmp);
 		if (memcmp(aes_ecb_vectors[i].ciphertext, tmp, 16) != 0)
 			break;
 
 		DecipherBlock(cipher, tmp, ks_tmp);
 		if (memcmp(aes_ecb_vectors[i].plaintext, tmp, 16) != 0)
 			break;
 	}
 	if (i != AES_TEST_COUNT)
 		bFailed = TRUE;
 
 	// AES EncipherBlocks()/DecipherBlocks()
 	{
 		uint8 testData[1024];
 		uint32 origCrc;
-		size_t i;
 
 		for (i = 0; i < sizeof (testData); ++i)
 		{
 			testData[i] = (uint8) i;
 		}
 
 		origCrc = GetCrc32 (testData, sizeof (testData));
 
 		CipherInit (AES, testData, ks_tmp);
 		EncipherBlocks (AES, testData, ks_tmp, sizeof (testData) / CipherGetBlockSize (AES));
 
 		if (GetCrc32 (testData, sizeof (testData)) != 0xb5cd5631)
 			bFailed = TRUE;
 
 		DecipherBlocks (AES, testData, ks_tmp, sizeof (testData) / CipherGetBlockSize (AES));
 
 		if (origCrc != GetCrc32 (testData, sizeof (testData)))
 			bFailed = TRUE;
 	}
 
     #ifndef WOLFCRYPT_BACKEND
 	/* Serpent */
 
 	for (i = 0; i < SERPENT_TEST_COUNT; i++)
 	{
 		int cipher = SERPENT;
 		memcpy(key, serpent_vectors[i].key, 32);
 		memcpy(tmp, serpent_vectors[i].plaintext, 16);
 		CipherInit(cipher, key, ks_tmp);
 
@@ -1499,267 +1487,267 @@ BOOL AutoTestAlgorithms (void)
 	{
 		exceptionCatched = TRUE;
 	}
 
 	if (exceptionCatched)
 	{
 		/* unexepected exception raised. Disable all CPU extended feature and try again */
 		EnableHwEncryption (hwEncryptionEnabled);
 		DisableCPUExtendedFeatures ();
 		__try
 		{
 			result = DoAutoTestAlgorithms();
 		}
 	    __except (EXCEPTION_EXECUTE_HANDLER)
 		{
 			/* exception still occuring. Report failure. */
 			result = FALSE;
 		}
 	}
 #endif
 	return result;
 }
 
 BOOL test_hmac_sha256 ()
 {
 	unsigned int i;
 	int nTestsPerformed = 0;
 
 	for (i = 0; i < sizeof (hmac_sha256_test_data) / sizeof(char *); i++)
 	{
-		char digest[1024]; /* large enough to hold digets and test vector inputs */
+		unsigned char digest[1024]; /* large enough to hold digets and test vector inputs */
 		size_t dataLen = strlen (hmac_sha256_test_data[i]);
 		if (dataLen <= sizeof(digest))
 		{
 			memcpy (digest, hmac_sha256_test_data[i], dataLen);
-			hmac_sha256 (hmac_sha256_test_keys[i], (int) strlen (hmac_sha256_test_keys[i]), digest, (int) dataLen);
+			hmac_sha256 ((unsigned char*) hmac_sha256_test_keys[i], (int) strlen (hmac_sha256_test_keys[i]), digest, (int) dataLen);
 			if (memcmp (digest, hmac_sha256_test_vectors[i], SHA256_DIGESTSIZE) != 0)
 				return FALSE;
 			else
 				nTestsPerformed++;
 		}
 		else
 		{
 			return FALSE;
 		}
 	}
 
 	return (nTestsPerformed == 6);
 }
 
 BOOL test_hmac_sha512 ()
 {
 	unsigned int i;
 	int nTestsPerformed = 0;
 
 	for (i = 0; i < sizeof (hmac_sha512_test_data) / sizeof(char *); i++)
 	{
-		char digest[1024]; /* large enough to hold digets and test vector inputs */
+		unsigned char digest[1024]; /* large enough to hold digets and test vector inputs */
 		size_t dataLen = strlen (hmac_sha512_test_data[i]);
 		if (dataLen <= sizeof(digest))
 		{
 			memcpy (digest, hmac_sha512_test_data[i], dataLen );
-			hmac_sha512 (hmac_sha512_test_keys[i], (int) strlen (hmac_sha512_test_keys[i]), digest, (int) dataLen);
+			hmac_sha512 ((unsigned char*) hmac_sha512_test_keys[i], (int) strlen (hmac_sha512_test_keys[i]), digest, (int) dataLen);
 			if (memcmp (digest, hmac_sha512_test_vectors[i], SHA512_DIGESTSIZE) != 0)
 				return FALSE;
 			else
 				nTestsPerformed++;
 		}
 		else
 		{
 			return FALSE;
 		}
 	}
 
 	return (nTestsPerformed == 6);
 }
 
 #ifndef WOLFCRYPT_BACKEND
 BOOL test_hmac_blake2s ()
 {
 	unsigned int i;
 	int nTestsPerformed = 0;
 
 	for (i = 0; i < sizeof (hmac_blake2s_test_data) / sizeof(char *); i++)
 	{
-		char digest[1024]; /* large enough to hold digets and test vector inputs */
+		unsigned char digest[1024]; /* large enough to hold digets and test vector inputs */
 		size_t dataLen = strlen (hmac_blake2s_test_data[i]);
 		if (dataLen <= sizeof(digest))
 		{
 			memcpy (digest, hmac_blake2s_test_data[i], dataLen);
-			hmac_blake2s (hmac_blake2s_test_keys[i], (int) strlen (hmac_blake2s_test_keys[i]), digest, (int) dataLen);
+			hmac_blake2s ((unsigned char*)(unsigned char*)hmac_blake2s_test_keys[i], (int) strlen (hmac_blake2s_test_keys[i]), digest, (int) dataLen);
 			if (memcmp (digest, hmac_blake2s_test_vectors[i], BLAKE2S_DIGESTSIZE) != 0)
 				return FALSE;
 			else
 				nTestsPerformed++;
 		}
 		else
 		{
 			return FALSE;
 		}
 	}
 
 	return (nTestsPerformed == 6);
 }
 
 int __cdecl Blake2sHash (unsigned char* input, unsigned long inputLen, unsigned char* output)
 {
 	blake2s(output, input, (size_t) inputLen);
 	return BLAKE2S_DIGESTSIZE;
 }
 
 BOOL test_hmac_whirlpool ()
 {
 	unsigned char digest[1024]; /* large enough to hold digets and test vector inputs */
 
 	memcpy (digest, hmac_whirlpool_test_data, strlen (hmac_whirlpool_test_data));
-	hmac_whirlpool (hmac_whirlpool_test_key, 64, digest, (int) strlen (hmac_whirlpool_test_data));
+	hmac_whirlpool ((unsigned char*) hmac_whirlpool_test_key, 64, digest, (int) strlen (hmac_whirlpool_test_data));
 	if (memcmp (digest, hmac_whirlpool_test_vectors, WHIRLPOOL_DIGESTSIZE) != 0)
 		return FALSE;
 
 	return TRUE;
 }
 #endif
 
 /* http://www.tc26.ru/methods/recommendation/%D0%A2%D0%9A26%D0%90%D0%9B%D0%93.pdf */
 /* https://tools.ietf.org/html/draft-smyshlyaev-gost-usage-00 */
 /* https://datatracker.ietf.org/doc/rfc7836/?include_text=1 */
 static const unsigned char gost3411_2012_hmac_k1[] = {
 	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
 };
 static const unsigned char gost3411_2012_hmac_m1[] = {
 	0x01, 0x26, 0xbd, 0xb8, 0x78, 0x00, 0xaf, 0x21,
 	0x43, 0x41, 0x45, 0x65, 0x63, 0x78, 0x01, 0x00
 };
 static const unsigned char gost3411_2012_hmac_r1[] = {
 	0xA5, 0x9B, 0xAB, 0x22, 0xEC, 0xAE, 0x19, 0xC6, 0x5F, 0xBD, 0xE6, 0xE5,
 	0xF4, 0xE9, 0xF5, 0xD8, 0x54, 0x9D, 0x31, 0xF0, 0x37, 0xF9, 0xDF, 0x9B,
 	0x90, 0x55, 0x00, 0xE1, 0x71, 0x92, 0x3A, 0x77, 0x3D, 0x5F, 0x15, 0x30,
 	0xF2, 0xED, 0x7E, 0x96, 0x4C, 0xB2, 0xEE, 0xDC, 0x29, 0xE9, 0xAD, 0x2F,
 	0x3A, 0xFE, 0x93, 0xB2, 0x81, 0x4F, 0x79, 0xF5, 0x00, 0x0F, 0xFC, 0x03,
 	0x66, 0xC2, 0x51, 0xE6
 };
 
 
 #ifndef WOLFCRYPT_BACKEND
 BOOL test_hmac_streebog ()
 {
-	CRYPTOPP_ALIGN_DATA(16) char digest[64]; /* large enough to hold digets and test vector inputs */
+	CRYPTOPP_ALIGN_DATA(16) unsigned char digest[64]; /* large enough to hold digets and test vector inputs */
 
 	memcpy (digest, gost3411_2012_hmac_m1, sizeof (gost3411_2012_hmac_m1));
-	hmac_streebog ((char*) gost3411_2012_hmac_k1, sizeof(gost3411_2012_hmac_k1), digest, (int) sizeof (gost3411_2012_hmac_m1));
+	hmac_streebog ((unsigned char*) gost3411_2012_hmac_k1, sizeof(gost3411_2012_hmac_k1), digest, (int) sizeof (gost3411_2012_hmac_m1));
 	if (memcmp (digest, gost3411_2012_hmac_r1, STREEBOG_DIGESTSIZE) != 0)
 		return FALSE;
 
 	return TRUE;
 }
 
 int __cdecl StreebogHash (unsigned char* input, unsigned long inputLen, unsigned char* output)
 {
 	STREEBOG_CTX ctx;
 	STREEBOG_init (&ctx);
 	STREEBOG_add (&ctx, input, inputLen);
 	STREEBOG_finalize (&ctx, output);
 	return STREEBOG_DIGESTSIZE;
 }
 #endif
 
 BOOL test_pkcs5 ()
 {
-	char dk[144];
+	unsigned char dk[144];
 
 	/* HMAC-SHA-256 tests */
 	if (!test_hmac_sha256())
 		return FALSE;
 
 	/* HMAC-SHA-512 tests */
 	if (!test_hmac_sha512())
 		return FALSE;
 
 #ifndef WOLFCRYPT_BACKEND
 	/* HMAC-BLAKE2s tests */
 	if (test_hmac_blake2s() == FALSE)
 		return FALSE;
 
 	/* Blake2s hash tests */
-	if (RunHashTest (Blake2sHash, Blake2sTestVectors, (HasSSE2())? TRUE : FALSE) == FALSE)
+	if (RunHashTest (Blake2sHash, Blake2sTestVectors))
 		return FALSE;
 
 	/* HMAC-Whirlpool tests */
 	if (test_hmac_whirlpool() == FALSE)
 		return FALSE;
 
 	/* HMAC-STREEBOG tests */
 	if (test_hmac_streebog() == FALSE)
 		return FALSE;
 
 	/* STREEBOG hash tests */
-	if (RunHashTest (StreebogHash, Streebog512TestVectors, (HasSSE2() || HasSSE41())? TRUE : FALSE) == FALSE)
+	if (RunHashTest (StreebogHash, Streebog512TestVectors))
 		return FALSE;
 #endif
 	/* PKCS-5 test 1 with HMAC-SHA-256 used as the PRF (https://tools.ietf.org/html/draft-josefsson-scrypt-kdf-00) */
-	derive_key_sha256 ("passwd", 6, "\x73\x61\x6C\x74", 4, 1, dk, 64);
+	derive_key_sha256 ((unsigned char*) "passwd", 6, (unsigned char*) "\x73\x61\x6C\x74", 4, 1, dk, 64);
 	if (memcmp (dk, "\x55\xac\x04\x6e\x56\xe3\x08\x9f\xec\x16\x91\xc2\x25\x44\xb6\x05\xf9\x41\x85\x21\x6d\xde\x04\x65\xe6\x8b\x9d\x57\xc2\x0d\xac\xbc\x49\xca\x9c\xcc\xf1\x79\xb6\x45\x99\x16\x64\xb3\x9d\x77\xef\x31\x7c\x71\xb8\x45\xb1\xe3\x0b\xd5\x09\x11\x20\x41\xd3\xa1\x97\x83", 64) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 2 with HMAC-SHA-256 used as the PRF (https://stackoverflow.com/questions/5130513/pbkdf2-hmac-sha2-test-vectors) */
-	derive_key_sha256 ("password", 8, "\x73\x61\x6C\x74", 4, 2, dk, 32);
+	derive_key_sha256 ((unsigned char*) "password", 8, (unsigned char*) "\x73\x61\x6C\x74", 4, 2, dk, 32);
 	if (memcmp (dk, "\xae\x4d\x0c\x95\xaf\x6b\x46\xd3\x2d\x0a\xdf\xf9\x28\xf0\x6d\xd0\x2a\x30\x3f\x8e\xf3\xc2\x51\xdf\xd6\xe2\xd8\x5a\x95\x47\x4c\x43", 32) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 3 with HMAC-SHA-256 used as the PRF (MS CryptoAPI) */
-	derive_key_sha256 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);
+	derive_key_sha256 ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 4);
 	if (memcmp (dk, "\xf2\xa0\x4f\xb2", 4) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 4 with HMAC-SHA-256 used as the PRF (MS CryptoAPI) */
-	derive_key_sha256 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 144);
+	derive_key_sha256 ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 144);
 	if (memcmp (dk, "\xf2\xa0\x4f\xb2\xd3\xe9\xa5\xd8\x51\x0b\x5c\x06\xdf\x70\x8e\x24\xe9\xc7\xd9\x15\x3d\x22\xcd\xde\xb8\xa6\xdb\xfd\x71\x85\xc6\x99\x32\xc0\xee\x37\x27\xf7\x24\xcf\xea\xa6\xac\x73\xa1\x4c\x4e\x52\x9b\x94\xf3\x54\x06\xfc\x04\x65\xa1\x0a\x24\xfe\xf0\x98\x1d\xa6\x22\x28\xeb\x24\x55\x74\xce\x6a\x3a\x28\xe2\x04\x3a\x59\x13\xec\x3f\xf2\xdb\xcf\x58\xdd\x53\xd9\xf9\x17\xf6\xda\x74\x06\x3c\x0b\x66\xf5\x0f\xf5\x58\xa3\x27\x52\x8c\x5b\x07\x91\xd0\x81\xeb\xb6\xbc\x30\x69\x42\x71\xf2\xd7\x18\x42\xbe\xe8\x02\x93\x70\x66\xad\x35\x65\xbc\xf7\x96\x8e\x64\xf1\xc6\x92\xda\xe0\xdc\x1f\xb5\xf4", 144) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 1 with HMAC-SHA-512 used as the PRF */
-	derive_key_sha512 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);
+	derive_key_sha512 ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 4);
 	if (memcmp (dk, "\x13\x64\xae\xf8", 4) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 2 with HMAC-SHA-512 used as the PRF (derives a key longer than the underlying
 	hash output size and block size) */
-	derive_key_sha512 ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 144);
+	derive_key_sha512 ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 144);
 	if (memcmp (dk, "\x13\x64\xae\xf8\x0d\xf5\x57\x6c\x30\xd5\x71\x4c\xa7\x75\x3f\xfd\x00\xe5\x25\x8b\x39\xc7\x44\x7f\xce\x23\x3d\x08\x75\xe0\x2f\x48\xd6\x30\xd7\x00\xb6\x24\xdb\xe0\x5a\xd7\x47\xef\x52\xca\xa6\x34\x83\x47\xe5\xcb\xe9\x87\xf1\x20\x59\x6a\xe6\xa9\xcf\x51\x78\xc6\xb6\x23\xa6\x74\x0d\xe8\x91\xbe\x1a\xd0\x28\xcc\xce\x16\x98\x9a\xbe\xfb\xdc\x78\xc9\xe1\x7d\x72\x67\xce\xe1\x61\x56\x5f\x96\x68\xe6\xe1\xdd\xf4\xbf\x1b\x80\xe0\x19\x1c\xf4\xc4\xd3\xdd\xd5\xd5\x57\x2d\x83\xc7\xa3\x37\x87\xf4\x4e\xe0\xf6\xd8\x6d\x65\xdc\xa0\x52\xa3\x13\xbe\x81\xfc\x30\xbe\x7d\x69\x58\x34\xb6\xdd\x41\xc6", 144) != 0)
 		return FALSE;
 
 #ifndef WOLFCRYPT_BACKEND
 	/* PKCS-5 test 1 with HMAC-BLAKE2s used as the PRF */
-	derive_key_blake2s ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);
+	derive_key_blake2s ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 4);
 	if (memcmp (dk, "\x8d\x51\xfa\x31", 4) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 2 with HMAC-BLAKE2s used as the PRF (derives a key longer than the underlying hash) */
-	derive_key_blake2s ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 48);
+	derive_key_blake2s ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 48);
 	if (memcmp (dk, "\x8d\x51\xfa\x31\x46\x25\x37\x67\xa3\x29\x6b\x3c\x6b\xc1\x5d\xb2\xee\xe1\x6c\x28\x00\x26\xea\x08\x65\x9c\x12\xf1\x07\xde\x0d\xb9\x9b\x4f\x39\xfa\xc6\x80\x26\xb1\x8f\x8e\x48\x89\x85\x2d\x24\x2d", 48) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 1 with HMAC-Whirlpool used as the PRF */
-	derive_key_whirlpool ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);
+	derive_key_whirlpool ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 4);
 	if (memcmp (dk, "\x50\x7c\x36\x6f", 4) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 2 with HMAC-Whirlpool used as the PRF (derives a key longer than the underlying hash) */
-	derive_key_whirlpool ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 96);
+	derive_key_whirlpool ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 96);
 	if (memcmp (dk, "\x50\x7c\x36\x6f\xee\x10\x2e\x9a\xe2\x8a\xd5\x82\x72\x7d\x27\x0f\xe8\x4d\x7f\x68\x7a\xcf\xb5\xe7\x43\x67\xaa\x98\x93\x52\x2b\x09\x6e\x42\xdf\x2c\x59\x4a\x91\x6d\x7e\x10\xae\xb2\x1a\x89\x8f\xb9\x8f\xe6\x31\xa9\xd8\x9f\x98\x26\xf4\xda\xcd\x7d\x65\x65\xde\x10\x95\x91\xb4\x84\x26\xae\x43\xa1\x00\x5b\x1e\xb8\x38\x97\xa4\x1e\x4b\xd2\x65\x64\xbc\xfa\x1f\x35\x85\xdb\x4f\x97\x65\x6f\xbd\x24", 96) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 1 with HMAC-STREEBOG used as the PRF */
-	derive_key_streebog ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);
+	derive_key_streebog ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 4);
 	if (memcmp (dk, "\xd0\x53\xa2\x30", 4) != 0)
 		return FALSE;
 
 	/* PKCS-5 test 2 with HMAC-STREEBOG used as the PRF (derives a key longer than the underlying hash) */
-	derive_key_streebog ("password", 8, "\x12\x34\x56\x78", 4, 5, dk, 96);
+	derive_key_streebog ((unsigned char*)"password", 8, (unsigned char*)"\x12\x34\x56\x78", 4, 5, dk, 96);
 	if (memcmp (dk, "\xd0\x53\xa2\x30\x6f\x45\x81\xeb\xbc\x06\x81\xc5\xe7\x53\xa8\x5d\xc7\xf1\x23\x33\x1e\xbe\x64\x2c\x3b\x0f\x26\xd7\x00\xe1\x95\xc9\x65\x26\xb1\x85\xbe\x1e\xe2\xf4\x9b\xfc\x6b\x14\x84\xda\x24\x61\xa0\x1b\x9e\x79\x5c\xee\x69\x6e\xf9\x25\xb1\x1d\xca\xa0\x31\xba\x02\x6f\x9e\x99\x0f\xdb\x25\x01\x5b\xf1\xc7\x10\x19\x53\x3b\x29\x3f\x18\x00\xd6\xfc\x85\x03\xdc\xf2\xe5\xe9\x5a\xb1\x1e\x61\xde", 96) != 0)
 		return FALSE;
 #endif
 	return TRUE;
 }