wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2026-01-27 13:42:20 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #7520 from bandi13/fixConversion

Browse Source 
Fix conversion
This commit is contained in:
David Garske
2024-05-14 11:26:37 -07:00
committed by GitHub
parent 7526f527d1 a1797f0d0d
commit 28bd4ebeea
34 changed files with 1250 additions and 1247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
wolfcrypt/benchmark/benchmark.c
View File

@@ -3018,7 +3018,7 @@ static void* benchmarks_do(void* args)
#ifndef NO_FILESYSTEM
if (hash_input) {
int rawSz;
size_t rawSz;
XFILE file;
file = XFOPEN(hash_input, "rb");
if (file == XBADFILE)
@@ -3037,7 +3037,7 @@ static void* benchmarks_do(void* args)
XFREE(bench_plain, HEAP_HINT, DYNAMIC_TYPE_WOLF_BIGINT);
rawSz = (int)bench_buf_size;
rawSz = (size_t)bench_buf_size;
if (bench_buf_size % 16)
bench_buf_size += 16 - (bench_buf_size % 16);
@@ -3052,7 +3052,7 @@ static void* benchmarks_do(void* args)
}
if ((size_t)XFREAD(bench_plain, 1, rawSz, file)
!= (size_t)rawSz) {
!= rawSz) {
XFCLOSE(file);
goto exit;
}
@@ -3064,7 +3064,7 @@ static void* benchmarks_do(void* args)
}
if (cipher_input) {
int rawSz;
size_t rawSz;
XFILE file;
file = XFOPEN(cipher_input, "rb");
if (file == XBADFILE)
@@ -3083,7 +3083,7 @@ static void* benchmarks_do(void* args)
XFREE(bench_cipher, HEAP_HINT, DYNAMIC_TYPE_WOLF_BIGINT);
rawSz = (int)bench_buf_size;
rawSz = (size_t)bench_buf_size;
if (bench_buf_size % 16)
bench_buf_size += 16 - (bench_buf_size % 16);
@@ -3099,7 +3099,7 @@ static void* benchmarks_do(void* args)
}
if ((size_t)XFREAD(bench_cipher, 1, rawSz, file)
!= (size_t)rawSz) {
!= rawSz) {
XFCLOSE(file);
goto exit;
}
@@ -4743,9 +4743,9 @@ static void bench_aesecb_internal(int useDeviceID,
double start;
DECLARE_MULTI_VALUE_STATS_VARS()
#ifdef HAVE_FIPS
const int benchSz = AES_BLOCK_SIZE;
const word32 benchSz = AES_BLOCK_SIZE;
#else
const int benchSz = (int)bench_size;
const word32 benchSz = bench_size;
#endif
WC_CALLOC_ARRAY(enc, Aes, BENCH_MAX_PENDING,
@@ -4768,7 +4768,7 @@ static void bench_aesecb_internal(int useDeviceID,
bench_stats_start(&count, &start);
do {
int outer_loop_limit = (((int)bench_size / benchSz) * 10) + 1;
int outer_loop_limit = (int)((bench_size / benchSz) * 10) + 1;
for (times = 0;
times < outer_loop_limit /* numBlocks */ || pending > 0;
) {
@@ -4821,7 +4821,7 @@ exit_aes_enc:
bench_stats_start(&count, &start);
do {
int outer_loop_limit = (10 * ((int)bench_size / benchSz)) + 1;
int outer_loop_limit = (int)(10 * (bench_size / benchSz)) + 1;
for (times = 0; times < outer_loop_limit || pending > 0; ) {
bench_async_poll(&pending);

4
wolfcrypt/src/asn.c
View File

@@ -37612,7 +37612,7 @@ int VerifyCRL_Signature(SignatureCtx* sigCtx, const byte* toBeSigned,
InitSignatureCtx(sigCtx, heap, INVALID_DEVID);
if (ConfirmSignature(sigCtx, toBeSigned, tbsSz, ca->publicKey,
ca->pubKeySize, ca->keyOID, signature, sigSz,
signatureOID, sigParams, sigParamsSz, NULL) != 0) {
signatureOID, sigParams, (word32)sigParamsSz, NULL) != 0) {
WOLFSSL_MSG("CRL Confirm signature failed");
WOLFSSL_ERROR_VERBOSE(ASN_CRL_CONFIRM_E);
return ASN_CRL_CONFIRM_E;
@@ -38336,7 +38336,7 @@ end:
buff);
dcrl->sigParamsIndex =
dataASN[CRLASN_IDX_SIGALGO_PARAMS].offset;
dcrl->sigParamsLength = sigParamsSz;
dcrl->sigParamsLength = (word32)sigParamsSz;
}
#endif

6
wolfcrypt/src/kdf.c
View File

@@ -564,14 +564,14 @@ int wc_PRF_TLS(byte* digest, word32 digLen, const byte* secret, word32 secLen,
const byte* info, word32 infoLen, int digest, void* heap)
{
int ret = 0;
int idx = 0;
int len;
word32 idx = 0;
size_t len;
byte *data;
(void)heap;
/* okmLen (2) + protocol|label len (1) + info len(1) + protocollen +
* labellen + infolen */
len = 4 + protocolLen + labelLen + infoLen;
len = (size_t)4 + protocolLen + labelLen + infoLen;
data = (byte*)XMALLOC(len, heap, DYNAMIC_TYPE_TMP_BUFFER);
if (data == NULL)

597
wolfcrypt/src/pkcs7.c
View File

File diff suppressed because it is too large Load Diff

292
wolfcrypt/test/test.c
View File

@@ -2174,7 +2174,7 @@ static wc_test_ret_t _SaveDerAndPem(const byte* der, int derSz,
if (!derFile) {
return WC_TEST_RET_ENC(calling_line, 0, WC_TEST_RET_TAG_I);
}
ret = (int)XFWRITE(der, 1, derSz, derFile);
ret = (int)XFWRITE(der, 1, (size_t)derSz, derFile);
XFCLOSE(derFile);
if (ret != derSz) {
return WC_TEST_RET_ENC(calling_line, 1, WC_TEST_RET_TAG_I);
@@ -2194,7 +2194,7 @@ static wc_test_ret_t _SaveDerAndPem(const byte* der, int derSz,
int pemSz;
/* calculate PEM size */
pemSz = wc_DerToPem(der, derSz, NULL, 0, pemType);
pemSz = wc_DerToPem(der, (word32)derSz, NULL, 0, pemType);
if (pemSz < 0) {
return WC_TEST_RET_ENC(calling_line, 2, WC_TEST_RET_TAG_I);
}
@@ -2208,7 +2208,7 @@ static wc_test_ret_t _SaveDerAndPem(const byte* der, int derSz,
return BAD_FUNC_ARG;
#endif
/* Convert to PEM */
pemSz = wc_DerToPem(der, derSz, pem, pemSz, pemType);
pemSz = wc_DerToPem(der, (word32)derSz, pem, pemSz, pemType);
if (pemSz < 0) {
XFREE(pem, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
return WC_TEST_RET_ENC(calling_line, 4, WC_TEST_RET_TAG_I);
@@ -2219,7 +2219,7 @@ static wc_test_ret_t _SaveDerAndPem(const byte* der, int derSz,
XFREE(pem, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
return WC_TEST_RET_ENC(calling_line, 5, WC_TEST_RET_TAG_I);
}
ret = (int)XFWRITE(pem, 1, pemSz, pemFile);
ret = (int)XFWRITE(pem, 1, (size_t)pemSz, pemFile);
XFCLOSE(pemFile);
if (ret != pemSz) {
XFREE(pem, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
@@ -3104,7 +3104,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t blake2b_test(void)
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
ret = wc_Blake2bUpdate(&b2b, input, i);
ret = wc_Blake2bUpdate(&b2b, input, (word32)i);
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
@@ -3166,7 +3166,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t blake2s_test(void)
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
ret = wc_Blake2sUpdate(&b2s, input, i);
ret = wc_Blake2sUpdate(&b2s, input, (word32)i);
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
@@ -5611,7 +5611,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hash_test(void)
if (ret != BUFFER_E)
return WC_TEST_RET_ENC_I(i);
}
ret = wc_Hash(typesGood[i], data, sizeof(data), hashOut, digestSz);
ret = wc_Hash(typesGood[i], data, sizeof(data), hashOut, (word32)digestSz);
if (ret != exp_ret)
return WC_TEST_RET_ENC_I(i);
if (exp_ret == 0 && XMEMCMP(out, hashOut, digestSz) != 0)
@@ -6601,7 +6601,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hmac_sha3_test(void)
ret = wc_HmacFinal(&hmac, hash);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
if (XMEMCMP(hash, output[(i*jMax) + j], hashSz[j]) != 0)
if (XMEMCMP(hash, output[(i*jMax) + j], (size_t)hashSz[j]) != 0)
return WC_TEST_RET_ENC_NC;
wc_HmacFree(&hmac);
@@ -7019,10 +7019,10 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t arc4_test(void)
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ret = wc_Arc4SetKey(&enc, (byte*)keys[i], keylen);
ret = wc_Arc4SetKey(&enc, (byte*)keys[i], (word32)keylen);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ret = wc_Arc4SetKey(&dec, (byte*)keys[i], keylen);
ret = wc_Arc4SetKey(&dec, (byte*)keys[i], (word32)keylen);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
@@ -7370,8 +7370,8 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t chacha_test(void)
if (ret != 0)
return ret;
ret |= wc_Chacha_Process(&enc, cipher_big, plain_big , block_size);
ret |= wc_Chacha_Process(&dec, plain_big , cipher_big, block_size);
ret |= wc_Chacha_Process(&enc, cipher_big, plain_big , (word32)block_size);
ret |= wc_Chacha_Process(&dec, plain_big , cipher_big, (word32)block_size);
if (ret != 0)
return ret;
@@ -7401,19 +7401,19 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t chacha_test(void)
return WC_TEST_RET_ENC_EC(ret);
for (j = 0; j < CHACHA_BIG_TEST_SIZE - i; j+= i) {
ret = wc_Chacha_Process(&enc, cipher_big + j, plain_big + j, i);
ret = wc_Chacha_Process(&enc, cipher_big + j, plain_big + j, (word32)i);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ret = wc_Chacha_Process(&dec, plain_big + j, cipher_big + j, i);
ret = wc_Chacha_Process(&dec, plain_big + j, cipher_big + j, (word32)i);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
}
rem = CHACHA_BIG_TEST_SIZE - j;
ret = wc_Chacha_Process(&enc, cipher_big + j, plain_big + j, rem);
ret = wc_Chacha_Process(&enc, cipher_big + j, plain_big + j, (word32)rem);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
ret = wc_Chacha_Process(&dec, plain_big + j, cipher_big + j, rem);
ret = wc_Chacha_Process(&dec, plain_big + j, cipher_big + j, (word32)rem);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
@@ -10218,7 +10218,7 @@ static wc_test_ret_t aes_xts_128_test(void)
ret = wc_AesXtsSetKeyNoInit(aes, k1, sizeof(k1), AES_ENCRYPTION);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_AesXtsEncrypt(aes, large_input, large_input, j, i1,
ret = wc_AesXtsEncrypt(aes, large_input, large_input, (word32)j, i1,
sizeof(i1));
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = wc_AsyncWait(ret, &aes->aes.asyncDev, WC_ASYNC_FLAG_NONE);
@@ -10229,7 +10229,7 @@ static wc_test_ret_t aes_xts_128_test(void)
ret = wc_AesXtsSetKeyNoInit(aes, k1, sizeof(k1), AES_DECRYPTION);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_AesXtsDecrypt(aes, large_input, large_input, j, i1,
ret = wc_AesXtsDecrypt(aes, large_input, large_input, (word32)j, i1,
sizeof(i1));
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WC_AES_XTS_SUPPORT_SIMULTANEOUS_ENC_AND_DEC_KEYS
@@ -11676,33 +11676,33 @@ static wc_test_ret_t aesctr_test(Aes* enc, Aes* dec, byte* cipher, byte* plain)
for (i = 0; i < AES_CTR_TEST_LEN; i++) {
if (testVec[i].key != NULL) {
ret = wc_AesSetKeyDirect(enc, testVec[i].key, testVec[i].keySz,
ret = wc_AesSetKeyDirect(enc, testVec[i].key, (word32)testVec[i].keySz,
testVec[i].iv, AES_ENCRYPTION);
if (ret != 0) {
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
}
/* Ctr only uses encrypt, even on key setup */
ret = wc_AesSetKeyDirect(dec, testVec[i].key, testVec[i].keySz,
ret = wc_AesSetKeyDirect(dec, testVec[i].key, (word32)testVec[i].keySz,
testVec[i].iv, AES_ENCRYPTION);
if (ret != 0) {
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
}
}
ret = wc_AesCtrEncrypt(enc, cipher, testVec[i].plain, testVec[i].len);
ret = wc_AesCtrEncrypt(enc, cipher, testVec[i].plain, (word32)testVec[i].len);
if (ret != 0) {
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
}
ret = wc_AesCtrEncrypt(dec, plain, cipher, testVec[i].len);
ret = wc_AesCtrEncrypt(dec, plain, cipher, (word32)testVec[i].len);
if (ret != 0) {
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
}
if (XMEMCMP(plain, ctrPlain, testVec[i].len)) {
if (XMEMCMP(plain, ctrPlain, (size_t)testVec[i].len)) {
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
}
#if !(FIPS_VERSION_EQ(2,0) && defined(WOLFSSL_ARMASM))
if (XMEMCMP(cipher, testVec[i].cipher, testVec[i].len)) {
if (XMEMCMP(cipher, testVec[i].cipher, (size_t)testVec[i].len)) {
ERROR_OUT(WC_TEST_RET_ENC_I(i), out);
}
#endif
@@ -12572,11 +12572,11 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes256_test(void)
dec_inited = 1;
#endif
ret = wc_AesSetKey(enc, key, keySz, iv, AES_ENCRYPTION);
ret = wc_AesSetKey(enc, key, (word32)keySz, iv, AES_ENCRYPTION);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
#ifdef HAVE_AES_DECRYPT
ret = wc_AesSetKey(dec, key, keySz, iv, AES_DECRYPTION);
ret = wc_AesSetKey(dec, key, (word32)keySz, iv, AES_DECRYPTION);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
#endif
@@ -12755,13 +12755,13 @@ static wc_test_ret_t aesgcm_default_test_helper(byte* key, int keySz, byte* iv,
else
dec_inited = 1;
ret = wc_AesGcmSetKey(enc, key, keySz);
ret = wc_AesGcmSetKey(enc, key, (word32)keySz);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
/* AES-GCM encrypt and decrypt both use AES encrypt internally */
ret = wc_AesGcmEncrypt(enc, resultC, plain, plainSz, iv, ivSz,
resultT, tagSz, aad, aadSz);
ret = wc_AesGcmEncrypt(enc, resultC, plain, (word32)plainSz, iv, ivSz,
resultT, (word32)tagSz, aad, aadSz);
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = wc_AsyncWait(ret, &enc->asyncDev, WC_ASYNC_FLAG_NONE);
#endif
@@ -12793,12 +12793,12 @@ static wc_test_ret_t aesgcm_default_test_helper(byte* key, int keySz, byte* iv,
#endif
#ifdef HAVE_AES_DECRYPT
ret = wc_AesGcmSetKey(dec, key, keySz);
ret = wc_AesGcmSetKey(dec, key, (word32)keySz);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
ret = wc_AesGcmDecrypt(dec, resultP, resultC, cipherSz,
iv, ivSz, resultT, tagSz, aad, aadSz);
ret = wc_AesGcmDecrypt(dec, resultP, resultC, (word32)cipherSz,
iv, (word32)ivSz, resultT, tagSz, aad, aadSz);
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = wc_AsyncWait(ret, &dec->asyncDev, WC_ASYNC_FLAG_NONE);
#endif
@@ -13199,7 +13199,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
#ifdef WOLFSSL_AES_256
ret = wc_AesGcmSetKey(enc, k1, k1Sz);
ret = wc_AesGcmSetKey(enc, k1, (word32)k1Sz);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@@ -13219,7 +13219,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
#endif
#ifdef HAVE_AES_DECRYPT
ret = wc_AesGcmSetKey(dec, k1, k1Sz);
ret = wc_AesGcmSetKey(dec, k1, (word32)k1Sz);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@@ -13365,7 +13365,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
for (plen=1; plen<BENCH_AESGCM_LARGE; plen++) {
/* AES-GCM encrypt and decrypt both use AES encrypt internally */
ret = wc_AesGcmEncrypt(enc, large_output, large_input,
plen, iv1, sizeof(iv1), resultT,
(word32)plen, iv1, sizeof(iv1), resultT,
sizeof(t1), a, sizeof(a));
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = wc_AsyncWait(ret, &enc->asyncDev, WC_ASYNC_FLAG_NONE);
@@ -13375,7 +13375,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
#ifdef HAVE_AES_DECRYPT
ret = wc_AesGcmDecrypt(dec, large_outdec, large_output,
plen, iv1, sizeof(iv1), resultT,
(word32)plen, iv1, sizeof(iv1), resultT,
sizeof(t1), a, sizeof(a));
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = wc_AsyncWait(ret, &dec->asyncDev, WC_ASYNC_FLAG_NONE);
@@ -13444,8 +13444,8 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
/* Large buffer test */
#ifdef BENCH_AESGCM_LARGE
wc_AesGcmSetKey(enc, k2, k3Sz);
wc_AesGcmSetKey(dec, k2, k3Sz);
wc_AesGcmSetKey(enc, k2, (word32)k3Sz);
wc_AesGcmSetKey(dec, k2, (word32)k3Sz);
/* setup test buffer */
for (alen=0; alen<BENCH_AESGCM_LARGE; alen++)
large_input[alen] = (byte)alen;
@@ -13479,7 +13479,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
XMEMSET(resultP, 0, sizeof(resultP));
#endif /* WOLFSSL_AES_192 */
#ifdef WOLFSSL_AES_128
wc_AesGcmSetKey(enc, k3, k3Sz);
wc_AesGcmSetKey(enc, k3, (word32)k3Sz);
/* AES-GCM encrypt and decrypt both use AES encrypt internally */
ret = wc_AesGcmEncrypt(enc, resultC, p3, sizeof(p3), iv3, sizeof(iv3),
resultT, sizeof(t3), a3, sizeof(a3));
@@ -13509,8 +13509,8 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
/* Large buffer test */
#ifdef BENCH_AESGCM_LARGE
wc_AesGcmSetKey(enc, k3, k3Sz);
wc_AesGcmSetKey(dec, k3, k3Sz);
wc_AesGcmSetKey(enc, k3, (word32)k3Sz);
wc_AesGcmSetKey(dec, k3, (word32)k3Sz);
/* setup test buffer */
for (alen=0; alen<BENCH_AESGCM_LARGE; alen++)
large_input[alen] = (byte)alen;
@@ -13549,7 +13549,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
XMEMSET(resultC, 0, sizeof(resultC));
XMEMSET(resultP, 0, sizeof(resultP));
wc_AesGcmSetKey(enc, k1, k1Sz);
wc_AesGcmSetKey(enc, k1, (word32)k1Sz);
/* AES-GCM encrypt and decrypt both use AES encrypt internally */
ret = wc_AesGcmEncrypt(enc, resultC, p, sizeof(p), iv1, sizeof(iv1),
resultT + 1, sizeof(t1) - 1, a, sizeof(a));
@@ -13595,7 +13595,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
XMEMSET(resultC, 0, sizeof(resultC));
XMEMSET(resultP, 0, sizeof(resultP));
wc_AesGcmSetKey(enc, k1, k1Sz);
wc_AesGcmSetKey(enc, k1, (word32)k1Sz);
ret = wc_AesGcmSetIV(enc, sizeof(randIV), NULL, 0, &rng);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@@ -13622,7 +13622,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
}
#ifdef HAVE_AES_DECRYPT
wc_AesGcmSetKey(dec, k1, k1Sz);
wc_AesGcmSetKey(dec, k1, (word32)k1Sz);
ret = wc_AesGcmSetIV(dec, sizeof(randIV), NULL, 0, &rng);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@@ -13687,7 +13687,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
for (plen = 0; plen < (int)sizeof(a); plen += alen) {
int len = sizeof(a) - plen;
if (len > alen) len = alen;
ret = wc_AesGcmEncryptUpdate(enc, NULL, NULL, 0, a + plen, len);
ret = wc_AesGcmEncryptUpdate(enc, NULL, NULL, 0, a + plen, (word32)len);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
}
@@ -13695,7 +13695,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
for (plen = 0; plen < (int)sizeof(p); plen += alen) {
int len = sizeof(p) - plen;
if (len > alen) len = alen;
ret = wc_AesGcmEncryptUpdate(enc, resultC + plen, p + plen, len,
ret = wc_AesGcmEncryptUpdate(enc, resultC + plen, p + plen, (word32)len,
NULL, 0);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@@ -13719,7 +13719,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
for (plen = 0; plen < (int)sizeof(a); plen += alen) {
int len = sizeof(a) - plen;
if (len > alen) len = alen;
ret = wc_AesGcmDecryptUpdate(enc, NULL, NULL, 0, a + plen, len);
ret = wc_AesGcmDecryptUpdate(enc, NULL, NULL, 0, a + plen, (word32)len);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
}
@@ -13727,7 +13727,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aesgcm_test(void)
for (plen = 0; plen < (int)sizeof(c1); plen += alen) {
int len = sizeof(c1) - plen;
if (len > alen) len = alen;
ret = wc_AesGcmDecryptUpdate(enc, resultP + plen, c1 + plen, len,
ret = wc_AesGcmDecryptUpdate(enc, resultP + plen, c1 + plen, (word32)len,
NULL, 0);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@@ -14441,18 +14441,18 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes_eax_test(void)
XMEMSET(ciphertext, 0, sizeof(ciphertext));
len = sizeof(authtag);
ret = wc_AesEaxEncryptAuth(vectors[i].key, vectors[i].key_length,
ret = wc_AesEaxEncryptAuth(vectors[i].key, (word32)vectors[i].key_length,
ciphertext,
vectors[i].msg, vectors[i].msg_length,
vectors[i].iv, vectors[i].iv_length,
authtag, len,
vectors[i].aad, vectors[i].aad_length);
vectors[i].msg, (word32)vectors[i].msg_length,
vectors[i].iv, (word32)vectors[i].iv_length,
authtag, (word32)len,
vectors[i].aad, (word32)vectors[i].aad_length);
if (ret != 0) {
return WC_TEST_RET_ENC_EC(ret);
}
/* check ciphertext matches vector */
if (XMEMCMP(ciphertext, vectors[i].ct, vectors[i].ct_length)) {
if (XMEMCMP(ciphertext, vectors[i].ct, (size_t)vectors[i].ct_length)) {
return WC_TEST_RET_ENC_NC;
}
@@ -14467,18 +14467,18 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aes_eax_test(void)
XMEMSET(ciphertext, 0, sizeof(ciphertext));
ret = wc_AesEaxDecryptAuth(vectors[i].key, vectors[i].key_length,
ret = wc_AesEaxDecryptAuth(vectors[i].key, (word32)vectors[i].key_length,
ciphertext,
vectors[i].ct, vectors[i].ct_length,
vectors[i].iv, vectors[i].iv_length,
authtag, len,
vectors[i].aad, vectors[i].aad_length);
vectors[i].ct, (word32)vectors[i].ct_length,
vectors[i].iv, (word32)vectors[i].iv_length,
authtag, (word32)len,
vectors[i].aad, (word32)vectors[i].aad_length);
if (ret != 0) {
return WC_TEST_RET_ENC_EC(ret);
}
/* check decrypted ciphertext matches vector plaintext */
if (XMEMCMP(ciphertext, vectors[i].msg, vectors[i].msg_length)) {
if (XMEMCMP(ciphertext, vectors[i].msg, (size_t)vectors[i].msg_length)) {
return WC_TEST_RET_ENC_NC;
}
@@ -14681,7 +14681,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t aeskeywrap_test(void)
return WC_TEST_RET_ENC_NC;
plainSz = wc_AesKeyUnWrap((byte*)test_wrap[i].kek, test_wrap[i].kekLen,
output, wrapSz,
output, (word32)wrapSz,
plain, sizeof(plain), NULL);
if ( (plainSz < 0) || (plainSz != (int)test_wrap[i].dataLen) )
@@ -17911,7 +17911,7 @@ static wc_test_ret_t rsa_pss_test(WC_RNG* rng, RsaKey* key)
ret = wc_Hash(hash[j], in, inLen, digest, sizeof(digest));
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa_pss);
digestSz = wc_HashGetDigestSize(hash[j]);
digestSz = (word32)wc_HashGetDigestSize(hash[j]);
#ifdef WOLFSSL_SE050
/* SE050 only supports MGF matched to same hash type */
@@ -17998,7 +17998,7 @@ static wc_test_ret_t rsa_pss_test(WC_RNG* rng, RsaKey* key)
/* SE050 generates salts internally only of hash length */
#ifndef WOLFSSL_SE050
/* Test that a salt length of zero works. */
digestSz = wc_HashGetDigestSize(hash[0]);
digestSz = (word32)wc_HashGetDigestSize(hash[0]);
outSz = RSA_TEST_BYTES;
do {
#if defined(WOLFSSL_ASYNC_CRYPT)
@@ -18084,7 +18084,7 @@ static wc_test_ret_t rsa_pss_test(WC_RNG* rng, RsaKey* key)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa_pss);
/* Test bad salt lengths in various APIs. */
digestSz = wc_HashGetDigestSize(hash[0]);
digestSz = (word32)wc_HashGetDigestSize(hash[0]);
outSz = RSA_TEST_BYTES;
#ifndef WOLFSSL_PSS_SALT_LEN_DISCOVER
len = -2;
@@ -18165,9 +18165,9 @@ static wc_test_ret_t rsa_pss_test(WC_RNG* rng, RsaKey* key)
if (ret != PSS_SALTLEN_E)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa_pss);
#ifndef WOLFSSL_PSS_LONG_SALT
len = digestSz + 1;
len = (int)(digestSz + 1);
#else
len = plainSz - digestSz - 1;
len = (int)(plainSz - digestSz - 1);
#endif
#if defined(HAVE_SELFTEST) && \
(!defined(HAVE_SELFTEST_VERSION) || (HAVE_SELFTEST_VERSION < 2))
@@ -18299,7 +18299,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_no_pad_test(void)
}
#ifndef WOLFSSL_RSA_VERIFY_ONLY
inLen = wc_RsaEncryptSize(key);
inLen = (word32)wc_RsaEncryptSize(key);
outSz = inLen;
plainSz = inLen;
XMEMSET(tmp, 7, inLen);
@@ -18361,7 +18361,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_no_pad_test(void)
ret = wc_AsyncWait(ret, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
#endif
if (ret >= 0) {
ret = wc_RsaPublicEncrypt_ex(tmp, inLen, out, (int)outSz, key, &rng,
ret = wc_RsaPublicEncrypt_ex(tmp, inLen, out, outSz, key, &rng,
WC_RSA_NO_PAD, WC_HASH_TYPE_NONE, WC_MGF1NONE, NULL, 0);
}
} while (ret == WC_PENDING_E);
@@ -18377,7 +18377,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_no_pad_test(void)
ret = wc_AsyncWait(ret, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
#endif
if (ret >= 0) {
ret = wc_RsaPrivateDecrypt_ex(out, outSz, plain, (int)plainSz, key,
ret = wc_RsaPrivateDecrypt_ex(out, outSz, plain, plainSz, key,
WC_RSA_NO_PAD, WC_HASH_TYPE_NONE, WC_MGF1NONE, NULL, 0);
}
} while (ret == WC_PENDING_E);
@@ -18723,7 +18723,7 @@ static wc_test_ret_t rsa_certgen_test(RsaKey* key, RsaKey* keypub, WC_RNG* rng,
if (ret < 0) {
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa);
}
certSz = (word32)ret;
certSz = (int)ret;
#ifdef WOLFSSL_TEST_CERT
InitDecodedCert(decode, der, certSz, HEAP_HINT);
@@ -18883,7 +18883,7 @@ static wc_test_ret_t rsa_certgen_test(RsaKey* key, RsaKey* keypub, WC_RNG* rng,
} while (ret == WC_PENDING_E);
if (ret < 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa);
certSz = (word32)ret;
certSz = (int)ret;
#ifdef WOLFSSL_TEST_CERT
InitDecodedCert(decode, der, certSz, HEAP_HINT);
@@ -19112,7 +19112,7 @@ static wc_test_ret_t rsa_ecc_certgen_test(WC_RNG* rng, byte* tmp)
} while (ret == WC_PENDING_E);
if (ret < 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa);
certSz = (word32)ret;
certSz = (int)ret;
#ifdef WOLFSSL_TEST_CERT
InitDecodedCert(decode, der, certSz, 0);
@@ -19249,7 +19249,7 @@ static wc_test_ret_t rsa_keygen_test(WC_RNG* rng)
#ifndef WOLFSSL_CRYPTOCELL
idx = 0;
/* The private key part of the key gen pairs from cryptocell can't be exported */
ret = wc_RsaPrivateKeyDecode(der, &idx, genKey, derSz);
ret = wc_RsaPrivateKeyDecode(der, &idx, genKey, (word32)derSz);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa);
#endif /* WOLFSSL_CRYPTOCELL */
@@ -20190,7 +20190,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t rsa_test(void)
} while (ret == WC_PENDING_E);
if (ret < 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit_rsa);
derSz = (word32)ret;
derSz = (int)ret;
ret = SaveDerAndPem(der, derSz, certReqDerFile, certReqPemFile,
CERTREQ_TYPE);
@@ -21477,7 +21477,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t dsa_test(void)
derIn_inited = 1;
idx = 0;
ret = wc_DsaPrivateKeyDecode(der, &idx, derIn, derSz);
ret = wc_DsaPrivateKeyDecode(der, &idx, derIn, (word32)derSz);
if (ret != 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
}
@@ -24376,7 +24376,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t openssl_pkey1_test(void)
#endif
XMEMSET(cipher, 0, RSA_TEST_BYTES);
outlen = keyLenBits/8;
outlen = (size_t)(keyLenBits/8);
if (EVP_PKEY_encrypt(enc, cipher, &outlen, msg, sizeof(msg)) < 0) {
ret = WC_TEST_RET_ENC_EC(ret);
goto openssl_pkey1_test_done;
@@ -25052,7 +25052,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hkdf_test(void)
#ifndef NO_SHA
ret = wc_HKDF(WC_SHA, ikm1, (word32)sizeof(ikm1), NULL, 0, NULL, 0,
okm1, L);
okm1, (word32)L);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
@@ -25063,7 +25063,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hkdf_test(void)
/* fips can't have key size under 14 bytes, salt is key too */
L = (int)sizeof(okm1);
ret = wc_HKDF(WC_SHA, ikm1, 11, salt1, (word32)sizeof(salt1),
info1, (word32)sizeof(info1), okm1, L);
info1, (word32)sizeof(info1), okm1, (word32)L);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
@@ -25074,7 +25074,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hkdf_test(void)
#ifndef NO_SHA256
ret = wc_HKDF(WC_SHA256, ikm1, (word32)sizeof(ikm1), NULL, 0, NULL, 0,
okm1, L);
okm1, (word32)L);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
@@ -25084,7 +25084,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t hkdf_test(void)
#ifndef HAVE_FIPS
/* fips can't have key size under 14 bytes, salt is key too */
ret = wc_HKDF(WC_SHA256, ikm1, (word32)sizeof(ikm1),
salt1, (word32)sizeof(salt1), info1, (word32)sizeof(info1), okm1, L);
salt1, (word32)sizeof(salt1), info1, (word32)sizeof(info1), okm1, (word32)L);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
@@ -25295,7 +25295,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t prf_test(void)
int lblsdL = LBSL;
int hash_type = sha384_mac;
ret = wc_PRF(dig, digL, secret, secL, lablSd, lblsdL, hash_type,
ret = wc_PRF(dig, (word32)digL, secret, secL, lablSd, lblsdL, hash_type,
HEAP_HINT, INVALID_DEVID);
if (ret != 0) {
printf("Failed w/ code: %d\n", ret);
@@ -25941,7 +25941,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t tls13_kdf_test(void)
hashAlgSz = wc_HashGetDigestSize(tv->hashAlg);
if (hashAlgSz == BAD_FUNC_ARG) break;
ret = wc_Hash(tv->hashAlg, NULL, 0, hashZero, hashAlgSz);
ret = wc_Hash(tv->hashAlg, NULL, 0, hashZero, (word32)hashAlgSz);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Extract(secret, NULL, 0,
@@ -25949,105 +25949,105 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t tls13_kdf_test(void)
tv->pskSz, tv->hashAlg);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(output, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(output, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)ceTrafficLabel, (word32)XSTRLEN(ceTrafficLabel),
tv->hashHello1, hashAlgSz, tv->hashAlg);
tv->hashHello1, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = XMEMCMP(tv->clientEarlyTrafficSecret, output, hashAlgSz);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(output, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(output, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)eExpMasterLabel, (word32)XSTRLEN(eExpMasterLabel),
tv->hashHello1, hashAlgSz, tv->hashAlg);
tv->hashHello1, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = XMEMCMP(tv->earlyExporterMasterSecret, output, hashAlgSz);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(salt, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(salt, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)derivedLabel, (word32)XSTRLEN(derivedLabel),
hashZero, hashAlgSz, tv->hashAlg);
hashZero, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Extract(secret, salt, hashAlgSz,
ret = wc_Tls13_HKDF_Extract(secret, salt, (word32)(word32)hashAlgSz,
(tv->dheSz == 0) ? zeroes : (byte*)tv->dhe,
tv->dheSz, tv->hashAlg);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(output, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(output, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)cHsTrafficLabel, (word32)XSTRLEN(cHsTrafficLabel),
tv->hashHello2, hashAlgSz, tv->hashAlg);
tv->hashHello2, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = XMEMCMP(tv->clientHandshakeTrafficSecret,
output, hashAlgSz);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(output, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(output, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)sHsTrafficLabel, (word32)XSTRLEN(sHsTrafficLabel),
tv->hashHello2, hashAlgSz, tv->hashAlg);
tv->hashHello2, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = XMEMCMP(tv->serverHandshakeTrafficSecret, output, hashAlgSz);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(salt, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(salt, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)derivedLabel, (word32)XSTRLEN(derivedLabel),
hashZero, hashAlgSz, tv->hashAlg);
hashZero, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Extract(secret, salt, hashAlgSz,
zeroes, hashAlgSz, tv->hashAlg);
ret = wc_Tls13_HKDF_Extract(secret, salt, (word32)(word32)hashAlgSz,
zeroes, (word32)(word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(output, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(output, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)cAppTrafficLabel, (word32)XSTRLEN(cAppTrafficLabel),
tv->hashFinished1, hashAlgSz, tv->hashAlg);
tv->hashFinished1, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = XMEMCMP(tv->clientApplicationTrafficSecret, output, hashAlgSz);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(output, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(output, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)sAppTrafficLabel, (word32)XSTRLEN(sAppTrafficLabel),
tv->hashFinished1, hashAlgSz, tv->hashAlg);
tv->hashFinished1, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = XMEMCMP(tv->serverApplicationTrafficSecret, output, hashAlgSz);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(output, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(output, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)expMasterLabel, (word32)XSTRLEN(expMasterLabel),
tv->hashFinished1, hashAlgSz, tv->hashAlg);
tv->hashFinished1, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = XMEMCMP(tv->exporterMasterSecret, output, hashAlgSz);
if (ret != 0) break;
ret = wc_Tls13_HKDF_Expand_Label(output, hashAlgSz,
secret, hashAlgSz,
ret = wc_Tls13_HKDF_Expand_Label(output, (word32)hashAlgSz,
secret, (word32)hashAlgSz,
(byte*)protocolLabel, (word32)XSTRLEN(protocolLabel),
(byte*)resMasterLabel, (word32)XSTRLEN(resMasterLabel),
tv->hashFinished2, hashAlgSz, tv->hashAlg);
tv->hashFinished2, (word32)hashAlgSz, tv->hashAlg);
if (ret != 0) break;
ret = XMEMCMP(tv->resumptionMasterSecret, output, hashAlgSz);
@@ -30619,7 +30619,7 @@ static wc_test_ret_t ecc_test_cert_gen(WC_RNG* rng)
} while (ret == WC_PENDING_E);
if (ret < 0)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), exit);
certSz = (word32)ret;
certSz = (int)ret;
TEST_SLEEP();
#ifdef WOLFSSL_TEST_CERT
@@ -32688,11 +32688,11 @@ static wc_test_ret_t curve25519_check_public_test(void)
for (i = 1; i < CURVE25519_KEYSIZE + 2; i++) {
if (i == CURVE25519_KEYSIZE)
continue;
if (wc_curve25519_check_public(good, i, EC25519_LITTLE_ENDIAN) !=
if (wc_curve25519_check_public(good, (word32)i, EC25519_LITTLE_ENDIAN) !=
ECC_BAD_ARG_E) {
return WC_TEST_RET_ENC_I(i);
}
if (wc_curve25519_check_public(good, i, EC25519_BIG_ENDIAN) !=
if (wc_curve25519_check_public(good, (word32)i, EC25519_BIG_ENDIAN) !=
ECC_BAD_ARG_E) {
return WC_TEST_RET_ENC_I(i);
}
@@ -33956,8 +33956,8 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t ed25519_test(void)
#endif
/* helper functions for signature and key size */
keySz = wc_ed25519_size(&key);
sigSz = wc_ed25519_sig_size(&key);
keySz = (word32)wc_ed25519_size(&key);
sigSz = (word32)wc_ed25519_sig_size(&key);
#if defined(HAVE_ED25519_SIGN) && defined(HAVE_ED25519_KEY_EXPORT) &&\
defined(HAVE_ED25519_KEY_IMPORT)
@@ -34293,11 +34293,11 @@ static wc_test_ret_t curve448_check_public_test(void)
for (i = 1; i < CURVE448_KEY_SIZE + 2; i++) {
if (i == CURVE448_KEY_SIZE)
continue;
if (wc_curve448_check_public(good, i, EC448_LITTLE_ENDIAN) !=
if (wc_curve448_check_public(good, (word32)i, EC448_LITTLE_ENDIAN) !=
ECC_BAD_ARG_E) {
return WC_TEST_RET_ENC_I(i);
}
if (wc_curve448_check_public(good, i, EC448_BIG_ENDIAN) !=
if (wc_curve448_check_public(good, (word32)i, EC448_BIG_ENDIAN) !=
ECC_BAD_ARG_E) {
return WC_TEST_RET_ENC_I(i);
}
@@ -35607,8 +35607,8 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t ed448_test(void)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
/* helper functions for signature and key size */
keySz = wc_ed448_size(key);
sigSz = wc_ed448_sig_size(key);
keySz = (word32)wc_ed448_size(key);
sigSz = (word32)wc_ed448_sig_size(key);
#if defined(HAVE_ED448_SIGN) && defined(HAVE_ED448_KEY_EXPORT) &&\
defined(HAVE_ED448_KEY_IMPORT)
@@ -41815,7 +41815,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t siphash_test(void)
ret = wc_InitSipHash(&siphash, siphash_key, SIPHASH_MAC_SIZE_8);
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
ret = wc_SipHashUpdate(&siphash, siphash_msg, i);
ret = wc_SipHashUpdate(&siphash, siphash_msg, (word32)i);
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
ret = wc_SipHashFinal(&siphash, res, SIPHASH_MAC_SIZE_8);
@@ -41823,7 +41823,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t siphash_test(void)
return WC_TEST_RET_ENC_I(i);
if (XMEMCMP(res, siphash_r8[i], SIPHASH_MAC_SIZE_8) != 0)
return WC_TEST_RET_ENC_I(i);
ret = wc_SipHash(siphash_key, siphash_msg, i, res, SIPHASH_MAC_SIZE_8);
ret = wc_SipHash(siphash_key, siphash_msg, (word32)i, res, SIPHASH_MAC_SIZE_8);
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
if (XMEMCMP(res, siphash_r8[i], SIPHASH_MAC_SIZE_8) != 0)
@@ -41833,7 +41833,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t siphash_test(void)
ret = wc_InitSipHash(&siphash, siphash_key, SIPHASH_MAC_SIZE_16);
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
ret = wc_SipHashUpdate(&siphash, siphash_msg, i);
ret = wc_SipHashUpdate(&siphash, siphash_msg, (word32)i);
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
ret = wc_SipHashFinal(&siphash, res, SIPHASH_MAC_SIZE_16);
@@ -41841,7 +41841,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t siphash_test(void)
return WC_TEST_RET_ENC_I(i);
if (XMEMCMP(res, siphash_r16[i], SIPHASH_MAC_SIZE_16) != 0)
return WC_TEST_RET_ENC_I(i);
ret = wc_SipHash(siphash_key, siphash_msg, i, res, SIPHASH_MAC_SIZE_16);
ret = wc_SipHash(siphash_key, siphash_msg, (word32)i, res, SIPHASH_MAC_SIZE_16);
if (ret != 0)
return WC_TEST_RET_ENC_I(i);
if (XMEMCMP(res, siphash_r16[i], SIPHASH_MAC_SIZE_16) != 0)
@@ -42787,9 +42787,9 @@ static int myDecryptionFunc(PKCS7* pkcs7, int encryptOID, byte* iv, int ivSz,
ret = wc_AesInit(aes, HEAP_HINT, INVALID_DEVID);
if (ret == 0) {
ret = wc_AesSetKey(aes, key, keySz, iv, AES_DECRYPTION);
ret = wc_AesSetKey(aes, key, (word32)keySz, iv, AES_DECRYPTION);
if (ret == 0)
ret = wc_AesCbcDecrypt(aes, out, in, inSz);
ret = wc_AesCbcDecrypt(aes, out, in, (word32)inSz);
wc_AesFree(aes);
}
@@ -43204,7 +43204,7 @@ static wc_test_ret_t pkcs7enveloped_run_vectors(byte* rsaCert, word32 rsaCertSz,
/* decode envelopedData */
pkcs7->contentOID = 0;
decodedSz = wc_PKCS7_DecodeEnvelopedData(pkcs7, enveloped, envelopedSz,
decodedSz = wc_PKCS7_DecodeEnvelopedData(pkcs7, enveloped, (word32)envelopedSz,
decoded, PKCS7_BUF_SIZE);
if (pkcs7->contentOID != testVectors[i].contentOID ||
decodedSz <= 0) {
@@ -43928,7 +43928,7 @@ static wc_test_ret_t pkcs7authenveloped_run_vectors(byte* rsaCert, word32 rsaCer
#endif
/* decode envelopedData */
decodedSz = wc_PKCS7_DecodeAuthEnvelopedData(pkcs7, enveloped,
envelopedSz, decoded,
(word32)envelopedSz, decoded,
PKCS7_BUF_SIZE);
if (decodedSz <= 0) {
wc_PKCS7_Free(pkcs7);
@@ -44284,7 +44284,7 @@ static wc_test_ret_t generateBundle(byte* out, word32 *outSz, const byte* encryp
if (ret <= 0) {
return ret;
}
attribs[1].valueSz = (int)ret;
attribs[1].valueSz = (word32)ret;
attribNum++;
}
@@ -44311,13 +44311,13 @@ static wc_test_ret_t generateBundle(byte* out, word32 *outSz, const byte* encryp
ret = wc_PKCS7_EncodeSignedEncryptedFPD(pkcs7, (byte*)encryptKey,
encryptKeySz, key, keySz, AES128CBCb, RSAk, SHA256h,
(byte*)data, sizeof(data), NULL, 0,
attribs, attribNum, out, *outSz);
attribs, (word32)attribNum, out, *outSz);
}
else {
ret = wc_PKCS7_EncodeSignedEncryptedFPD(pkcs7, (byte*)encryptKey,
encryptKeySz, key, keySz, AES256CBCb, RSAk, SHA256h,
(byte*)data, sizeof(data), NULL, 0,
attribs, attribNum, out, *outSz);
attribs, (word32)attribNum, out, *outSz);
}
if (ret <= 0) {
printf("ERROR: wc_PKCS7_EncodeSignedEncryptedFPD() failed, "
@@ -44326,7 +44326,7 @@ static wc_test_ret_t generateBundle(byte* out, word32 *outSz, const byte* encryp
return WC_TEST_RET_ENC_EC(ret);
} else {
*outSz = (int)ret;
*outSz = (word32)ret;
}
wc_PKCS7_Free(pkcs7);
@@ -44426,7 +44426,7 @@ static wc_test_ret_t verifyBundle(byte* derBuf, word32 derSz, int keyHint)
if (ret < 0)
goto out;
pkcs7->encryptionKey = key;
pkcs7->encryptionKeySz = (int)ret;
pkcs7->encryptionKeySz = (word32)ret;
}
else {
decodedSz = PKCS7_BUF_SIZE;
@@ -44440,7 +44440,7 @@ static wc_test_ret_t verifyBundle(byte* derBuf, word32 derSz, int keyHint)
}
decodedSz = wc_PKCS7_DecodeEncryptedData(pkcs7, pkcs7->content,
pkcs7->contentSz, decoded, decodedSz);
pkcs7->contentSz, decoded, (word32)decodedSz);
if (decodedSz < 0) {
ret = decodedSz;
goto out;
@@ -44717,7 +44717,7 @@ WOLFSSL_TEST_SUBROUTINE wc_test_ret_t pkcs7encrypted_test(void)
}
}
#endif
decodedSz = wc_PKCS7_DecodeEncryptedData(pkcs7, encrypted, encryptedSz,
decodedSz = wc_PKCS7_DecodeEncryptedData(pkcs7, encrypted, (word32)encryptedSz,
decoded, PKCS7_BUF_SIZE);
if (decodedSz <= 0){
wc_PKCS7_Free(pkcs7);
@@ -45395,7 +45395,7 @@ static wc_test_ret_t pkcs7signed_run_vectors(
int bufSz = 0;
if (testVectors[i].signedAttribs != NULL) {
ret = wc_PKCS7_GetAttributeValue(pkcs7, oidPt, oidSz,
ret = wc_PKCS7_GetAttributeValue(pkcs7, oidPt, (word32)oidSz,
NULL, (word32*)&bufSz);
if (ret != LENGTH_ONLY_E)
ERROR_OUT(WC_TEST_RET_ENC_EC(ret), out);
@@ -45405,7 +45405,7 @@ static wc_test_ret_t pkcs7signed_run_vectors(
if (bufSz > (int)sizeof(buf))
ERROR_OUT(WC_TEST_RET_ENC_NC, out);
bufSz = wc_PKCS7_GetAttributeValue(pkcs7, oidPt, oidSz,
bufSz = wc_PKCS7_GetAttributeValue(pkcs7, oidPt, (word32)oidSz,
buf, (word32*)&bufSz);
if ((testVectors[i].signedAttribs != NULL && bufSz < 0) ||
(testVectors[i].signedAttribs == NULL && bufSz > 0))
@@ -46161,10 +46161,10 @@ static wc_test_ret_t randNum(mp_int* n, int len, WC_RNG* rng, void* heap)
(void)heap;
do {
ret = wc_RNG_GenerateBlock(rng, d, len);
ret = wc_RNG_GenerateBlock(rng, d, (word32)len);
if (ret != 0)
return ret;
ret = mp_read_unsigned_bin(n, d, len);
ret = mp_read_unsigned_bin(n, d, (word32)len);
if (ret != 0)
return ret;
} while (mp_iszero(n));
@@ -46523,7 +46523,7 @@ static wc_test_ret_t mp_test_read_to_bin(mp_int* a)
for (i = 0; i < (int)sizeof(in); i++) {
p = in + sizeof(in) - i;
ret = mp_read_unsigned_bin(a, p, i);
ret = mp_read_unsigned_bin(a, p, (word32)i);
if (ret != 0)
return WC_TEST_RET_ENC_EC(ret);
for (j = i; j < (int)sizeof(out); j++) {
@@ -49225,7 +49225,7 @@ static wc_test_ret_t GenerateNextP(mp_int* p1, mp_int* p2, int k)
if (ret != 0)
ret = WC_TEST_RET_ENC_EC(ret);
if (ret == 0) {
ret = mp_set(ki, k);
ret = mp_set(ki, (mp_digit)k);
if (ret != 0)
ret = WC_TEST_RET_ENC_EC(ret);
}
@@ -49280,7 +49280,7 @@ static wc_test_ret_t GenerateP(mp_int* p1, mp_int* p2, mp_int* p3,
goto out;
}
for (i = 0; ret == 0 && i < ecPairsSz; i++) {
ret = mp_read_unsigned_bin(x, ecPairs[i].coeff, ecPairs[i].coeffSz);
ret = mp_read_unsigned_bin(x, ecPairs[i].coeff, (word32)ecPairs[i].coeffSz);
if (ret != 0) {
ret = WC_TEST_RET_ENC_EC(ret);
break;