{
int ret = 0;
unsigned char *rbuf = NULL, *sbuf = NULL;
- size_t r1_len, s1_len;
+ int r1_len, s1_len;
const BIGNUM *r1, *s1;
- ECDSA_SIG *sign = d2i_ECDSA_SIG(NULL, &sig, sig_len);
+ ECDSA_SIG *sign = d2i_ECDSA_SIG(NULL, &sig, (long)sig_len);
if (sign == NULL)
return 0;
EVP_PKEY *pkey = NULL;
EVP_PKEY_CTX *pkey_ctx;
ECDSA_SIG *sign = NULL;
- size_t sig_len;
+ int sig_len;
unsigned char *sig = NULL;
BIGNUM *rbn = NULL, *sbn = NULL;
const struct ecdsa_sigver_st *tst = &ecdsa_sigver_data[id];
goto err;
if (!TEST_ptr(sign = ECDSA_SIG_new())
- || !TEST_ptr(rbn = BN_bin2bn(tst->r, tst->r_len, NULL))
- || !TEST_ptr(sbn = BN_bin2bn(tst->s, tst->s_len, NULL))
+ || !TEST_ptr(rbn = BN_bin2bn(tst->r, (int)tst->r_len, NULL))
+ || !TEST_ptr(sbn = BN_bin2bn(tst->s, (int)tst->s_len, NULL))
|| !TEST_true(ECDSA_SIG_set0(sign, rbn, sbn)))
goto err;
rbn = sbn = NULL;
if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
|| !TEST_ptr(p_bn = BN_CTX_get(bn_ctx))
- || !TEST_ptr(BN_bin2bn(p, p_len, p_bn))
+ || !TEST_ptr(BN_bin2bn(p, (int)p_len, p_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_int(bld,
OSSL_PKEY_PARAM_FFC_VALIDATE_PQ,
validate_pq))
validate_g))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p_bn))
|| !TEST_ptr(q_bn = BN_CTX_get(bn_ctx))
- || !TEST_ptr(BN_bin2bn(q, q_len, q_bn))
+ || !TEST_ptr(BN_bin2bn(q, (int)q_len, q_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q_bn)))
goto err;
if (g != NULL) {
if (!TEST_ptr(g_bn = BN_CTX_get(bn_ctx))
- || !TEST_ptr(BN_bin2bn(g, g_len, g_bn))
+ || !TEST_ptr(BN_bin2bn(g, (int)g_len, g_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld,
OSSL_PKEY_PARAM_FFC_G, g_bn)))
goto err;
}
if (pub != NULL) {
if (!TEST_ptr(pub_bn = BN_CTX_get(bn_ctx))
- || !TEST_ptr(BN_bin2bn(pub, pub_len, pub_bn))
+ || !TEST_ptr(BN_bin2bn(pub, (int)pub_len, pub_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld,
OSSL_PKEY_PARAM_PUB_KEY,
pub_bn)))
{
int ret = 0;
unsigned char *rbuf = NULL, *sbuf = NULL;
- size_t r1_len, s1_len;
+ int r1_len, s1_len;
const BIGNUM *r1, *s1;
- DSA_SIG *sign = d2i_DSA_SIG(NULL, &sig, sig_len);
+ DSA_SIG *sign = d2i_DSA_SIG(NULL, &sig, (long)sig_len);
if (sign == NULL)
return 0;
EVP_PKEY_CTX *ctx = NULL;
EVP_PKEY *pkey = NULL;
DSA_SIG *sign = NULL;
- size_t sig_len;
+ int sig_len;
unsigned char *sig = NULL;
BIGNUM *rbn = NULL, *sbn = NULL;
EVP_MD *md = NULL;
goto err;
if (!TEST_ptr(sign = DSA_SIG_new())
- || !TEST_ptr(rbn = BN_bin2bn(tst->r, tst->r_len, NULL))
- || !TEST_ptr(sbn = BN_bin2bn(tst->s, tst->s_len, NULL))
+ || !TEST_ptr(rbn = BN_bin2bn(tst->r, (int)tst->r_len, NULL))
+ || !TEST_ptr(sbn = BN_bin2bn(tst->s, (int)tst->s_len, NULL))
|| !TEST_true(DSA_SIG_set0(sign, rbn, sbn)))
goto err;
rbn = sbn = NULL;
|| !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
|| !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc))
|| !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
- || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, pt_len))
+ || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, (int)pt_len))
|| !TEST_true(EVP_CipherFinal_ex(ctx, out + len, &out_len)))
goto err;
out_len += len;
if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
|| !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
|| !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc))
- || !TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len,
- NULL), 0)
- || !TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len,
+ || !TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,
+ (int)iv_len, NULL), 0)
+ || !TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, (int)tag_len,
enc ? NULL : (void *)tag), 0)
|| !TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc))
|| !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
- || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, NULL, pt_len))
- || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, aad_len))
- || !TEST_int_eq(EVP_CipherUpdate(ctx, out, &len, pt, pt_len), pass))
+ || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, NULL, (int)pt_len))
+ || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, (int)aad_len))
+ || !TEST_int_eq(EVP_CipherUpdate(ctx, out, &len, pt, (int)pt_len), pass))
goto err;
if (!pass) {
if (enc) {
out_len += len;
if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
- tag_len, out + out_len), 0)
+ (int)tag_len, out + out_len), 0)
|| !TEST_mem_eq(out, out_len, ct, ct_len)
|| !TEST_mem_eq(out + out_len, tag_len, tag, tag_len))
goto err;
if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
|| !TEST_ptr(cipher = EVP_CIPHER_fetch(libctx, alg, ""))
|| !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc))
- || !TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len,
- NULL), 0))
+ || !TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,
+ (int)iv_len, NULL), 0))
goto err;
if (!enc) {
- if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tag_len,
+ if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, (int)tag_len,
(void *)tag), 0))
goto err;
}
*/
if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc))
|| !TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))
- || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, aad_len))
- || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, pt_len)))
+ || !TEST_true(EVP_CipherUpdate(ctx, NULL, &len, aad, (int)aad_len))
+ || !TEST_true(EVP_CipherUpdate(ctx, out, &len, pt, (int)pt_len)))
goto err;
if (!TEST_int_eq(EVP_CipherFinal_ex(ctx, out + len, &olen), pass))
if (enc) {
if ((ct != NULL && !TEST_mem_eq(out, olen, ct, ct_len))
|| !TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
- tag_len, out + olen), 0)
+ (int)tag_len, out + olen), 0)
|| (tag != NULL
&& !TEST_mem_eq(out + olen, tag_len, tag, tag_len)))
goto err;
if (pub != NULL) {
if (!TEST_ptr(pub_bn = BN_CTX_get(bn_ctx))
- || !TEST_ptr(BN_bin2bn(pub, pub_len, pub_bn))
+ || !TEST_ptr(BN_bin2bn(pub, (int)pub_len, pub_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
pub_bn)))
goto err;
}
if (priv != NULL) {
if (!TEST_ptr(priv_bn = BN_CTX_get(bn_ctx))
- || !TEST_ptr(BN_bin2bn(priv, priv_len, priv_bn))
+ || !TEST_ptr(BN_bin2bn(priv, (int)priv_len, priv_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
priv_bn)))
goto err;
if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
|| !TEST_ptr(n_bn = BN_CTX_get(bn_ctx))
- || !TEST_ptr(BN_bin2bn(n, n_len, n_bn))
+ || !TEST_ptr(BN_bin2bn(n, (int)n_len, n_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n_bn)))
goto err;
if (e != NULL) {
if (!TEST_ptr(e_bn = BN_CTX_get(bn_ctx))
- || !TEST_ptr(BN_bin2bn(e, e_len, e_bn))
+ || !TEST_ptr(BN_bin2bn(e, (int)e_len, e_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E,
e_bn)))
goto err;
}
if (d != NULL) {
if (!TEST_ptr(d_bn = BN_CTX_get(bn_ctx))
- || !TEST_ptr(BN_bin2bn(d, d_len, d_bn))
+ || !TEST_ptr(BN_bin2bn(d, (int)d_len, d_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D,
d_bn)))
goto err;
const struct rsa_keygen_st *tst = &rsa_keygen_data[id];
if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
- || !TEST_ptr(xp1_bn = BN_bin2bn(tst->xp1, tst->xp1_len, NULL))
- || !TEST_ptr(xp2_bn = BN_bin2bn(tst->xp2, tst->xp2_len, NULL))
- || !TEST_ptr(xp_bn = BN_bin2bn(tst->xp, tst->xp_len, NULL))
- || !TEST_ptr(xq1_bn = BN_bin2bn(tst->xq1, tst->xq1_len, NULL))
- || !TEST_ptr(xq2_bn = BN_bin2bn(tst->xq2, tst->xq2_len, NULL))
- || !TEST_ptr(xq_bn = BN_bin2bn(tst->xq, tst->xq_len, NULL))
+ || !TEST_ptr(xp1_bn = BN_bin2bn(tst->xp1, (int)tst->xp1_len, NULL))
+ || !TEST_ptr(xp2_bn = BN_bin2bn(tst->xp2, (int)tst->xp2_len, NULL))
+ || !TEST_ptr(xp_bn = BN_bin2bn(tst->xp, (int)tst->xp_len, NULL))
+ || !TEST_ptr(xq1_bn = BN_bin2bn(tst->xq1, (int)tst->xq1_len, NULL))
+ || !TEST_ptr(xq2_bn = BN_bin2bn(tst->xq2, (int)tst->xq2_len, NULL))
+ || !TEST_ptr(xq_bn = BN_bin2bn(tst->xq, (int)tst->xq_len, NULL))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP1,
xp1_bn))
|| !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_TEST_XP2,
goto err;
if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL))
- || !TEST_ptr(e_bn = BN_bin2bn(tst->e, tst->e_len, NULL))
+ || !TEST_ptr(e_bn = BN_bin2bn(tst->e, (int)tst->e_len, NULL))
|| !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
|| !TEST_int_gt(EVP_PKEY_CTX_set_params(ctx, params), 0)
|| !TEST_int_gt(EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, tst->mod), 0)
&salt_len);
*p++ = OSSL_PARAM_construct_end();
- if (!TEST_ptr(pkey = EVP_PKEY_Q_keygen(libctx, NULL, "RSA", tst->mod))
+ if (!TEST_ptr(pkey = EVP_PKEY_Q_keygen(libctx, NULL, "RSA", (size_t)tst->mod))
|| !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_N, &n, &n_len))
|| !TEST_true(pkey_get_bn_bytes(pkey, OSSL_PKEY_PARAM_RSA_E, &e, &e_len))
|| !TEST_true(sig_gen(pkey, params, tst->digest_alg,
#ifndef OPENSSL_NO_DSA
struct dsa_paramgen_st {
- size_t L;
- size_t N;
+ int L;
+ int N;
};
struct dsa_pqver_st {
struct dsa_siggen_st {
const char *digest_alg;
- size_t L;
- size_t N;
+ int L;
+ int N;
const unsigned char *msg;
size_t msg_len;
};
#endif /* OPENSSL_NO_DH */
struct rsa_keygen_st {
- size_t mod;
+ int mod;
const unsigned char *e;
size_t e_len;
const unsigned char *xp1;
#define NO_PSS_SALT_LEN -1
struct rsa_siggen_st {
const char *sig_pad_mode;
- size_t mod;
+ int mod;
const char *digest_alg;
const unsigned char *msg;
size_t msg_len;
struct rsa_sigver_st {
const char *sig_pad_mode;
- size_t mod;
+ int mod;
const char *digest_alg;
const unsigned char *msg;
size_t msg_len;
int setup_tests(void)
{
OPTION_CHOICE o;
- int n, x509 = 0, spki = 0, testcount = 0;
+ size_t n;
+ int x509 = 0, spki = 0, testcount = 0;
while ((o = opt_next()) != OPT_EOF) {
switch (o) {
if (encoding_length == 0)
return -1;
- ret = do_decode(encoding, encoding_length, expected, expected_size,
+ ret = do_decode(encoding, (long)encoding_length, expected, expected_size,
package);
OPENSSL_free(encoding);
EXPECTED *expected
= (EXPECTED *)&((unsigned char *)package->encdec_data)[pos];
- switch (do_enc_dec(expected, package->encdec_data_elem_size, package)) {
+ switch (do_enc_dec(expected, (long)package->encdec_data_elem_size,
+ package)) {
case -1:
if (expected->success) {
TEST_error("Failed encode/decode round trip %u of %s",
int day, sec;
atime.data = (unsigned char*)td->data;
- atime.length = strlen((char*)atime.data);
+ atime.length = (int)strlen((char*)atime.data);
atime.type = td->type;
atime.flags = 0;
{
struct async_ctrs *ctrs;
int ret = 0;
- size_t written = 0;
+ int written = 0;
BIO *next = BIO_next(bio);
if (inl <= 0)
}
/* Write any data we have left after fragmenting */
ret = 0;
- if ((int)written < inl) {
+ if (written < inl) {
ret = BIO_write(next, in + written, inl - written);
}
static int async_puts(BIO *bio, const char *str)
{
- return async_write(bio, str, strlen(str));
+ return async_write(bio, str, (int)strlen(str));
}
#define MAX_ATTEMPTS 100
|| !TEST_ptr(enc_ctx = EVP_CIPHER_CTX_new())
|| !TEST_true(EVP_CipherInit_ex(enc_ctx, EVP_aes_128_cbc(), NULL,
enc_key, iv, 1))
- || !TEST_int_ge(EVP_Cipher(enc_ctx, enc, enc, len), 0))
+ || !TEST_int_ge(EVP_Cipher(enc_ctx, enc, enc, (unsigned int)len), 0))
goto end;
/* Finally write header (from fragmented variables), IV and encrypted record */
BIO_write(rbio, lenbytes, 2);
BIO_write(rbio, iv, sizeof(iv));
- BIO_write(rbio, enc, len);
+ BIO_write(rbio, enc, (int)len);
ret = 1;
end:
EVP_MAC_free(hmac);
BF_KEY key;
BF_LONG data[2];
- BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
+ BF_set_key(&key, (int)strlen(bf_key[n]), (unsigned char *)bf_key[n]);
data[0] = bf_plain[n][0];
data[1] = bf_plain[n][1];
BF_KEY key;
BF_LONG len;
- len = strlen(cbc_data) + 1;
+ len = (BF_LONG)(strlen(cbc_data) + 1);
BF_set_key(&key, 16, cbc_key);
memset(cbc_in, 0, sizeof(cbc_in));
BF_KEY key;
BF_LONG len;
- len = strlen(cbc_data) + 1;
+ len = (BF_LONG)(strlen(cbc_data) + 1);
BF_set_key(&key, 16, cbc_key);
memset(cbc_in, 0, 40);
BF_KEY key;
BF_LONG len;
- len = strlen(cbc_data) + 1;
+ len = (BF_LONG)(strlen(cbc_data) + 1);
BF_set_key(&key, 16, cbc_key);
memset(cbc_in, 0, 40);
/* Use a verbatim encoding when provided */
if (encoded != NULL) {
- int elen = strlen(encoded);
+ int elen = (int)strlen(encoded);
return BIO_write(mem, encoded, elen) == elen;
}
unsigned buflen, int trunc, char *encoded, unsigned llen,
unsigned wscnt, char **out)
{
- int preflen = strlen(prefix);
- int sufflen = strlen(suffix);
+ int preflen = (int)strlen(prefix);
+ int sufflen = (int)strlen(suffix);
int outlen;
char newline = '\n';
BUF_MEM *bptr;
/* Orphan the memory BIO's data buffer */
BIO_get_mem_ptr(mem, &bptr);
*out = bptr->data;
- outlen = bptr->length;
+ outlen = (int)bptr->length;
bptr->data = NULL;
(void) BIO_set_close(mem, BIO_NOCLOSE);
BIO_free(mem);
goto err;
BIO_set_callback_ex(bio, my_bio_cb_ex);
- i = BIO_write(bio, test1, test1len);
- if (!TEST_int_eq(i, test1len)
+ i = BIO_write(bio, test1, (int)test1len);
+ if (!TEST_int_eq(i, (int)test1len)
|| !TEST_int_eq(my_param_count, 2)
|| !TEST_ptr_eq(my_param_b[0], bio)
|| !TEST_int_eq(my_param_oper[0], BIO_CB_WRITE)
if (!TEST_ptr(bmem = BIO_new(BIO_s_mem())))
goto err;
BIO_push(bcomp, bmem);
- osize = BIO_write(bcomp, original, size);
- if (!TEST_int_eq(osize, size)
+ osize = BIO_write(bcomp, original, (int)size);
+ if (!TEST_int_eq(osize, (int)size)
|| !TEST_true(BIO_flush(bcomp)))
goto err;
BIO_free(bcomp);
if (!TEST_ptr(bexp = BIO_new(meth)))
goto err;
BIO_push(bexp, bmem);
- rsize = BIO_read(bexp, result, size);
+ rsize = BIO_read(bexp, result, (int)size);
- if (!TEST_int_eq(size, rsize)
+ if (!TEST_int_eq((int)size, rsize)
|| !TEST_mem_eq(original, osize, result, rsize))
goto err;
goto err;
buf[0] = '\0';
- if (!TEST_int_gt(BIO_write(cbio, msg, strlen(msg) + 1), 0)
+ if (!TEST_int_gt(BIO_write(cbio, msg, (int)(strlen(msg) + 1)), 0)
|| !TEST_int_gt(BIO_read(cbio, buf, sizeof(buf)), 0)
|| !TEST_str_eq(buf, msg))
goto err;
* set a buffer big enough for 9 full sized datagrams.
*/
bufsz = 9 * (mtu1 + (sizeof(BIO_ADDR) * 2) + sizeof(size_t));
- if (!TEST_true(BIO_set_write_buf_size(bio1, bufsz)))
+ if (!TEST_true(BIO_set_write_buf_size(bio1, (long)bufsz)))
goto err;
}
* the mtu. The default write buffer size is 9 * (sizeof(header) + mtu) so
* we expect at least 9 maximally sized datagrams to fit in the buffer.
*/
- if (!TEST_int_ge(i, 9))
+ if (!TEST_size_t_ge(i, 9))
goto err;
/* Check we read back the same data */
EVP_CIPHER_CTX *ctx = NULL;
BIO *mem = NULL, *b64 = NULL, *cbio = NULL;
unsigned char tag[16];
- size_t key_size, iv_size;
+ int key_size, iv_size;
int n, ret = 0;
memset(tag, 0, sizeof(tag));
if (!TEST_ptr(in = BIO_new_file(filename, "r"))
|| !TEST_int_eq(BIO_read_ex(in, expected, sizeof(expected),
&readbytes), 1)
- || !TEST_int_lt(readbytes, sizeof(expected)))
+ || !TEST_size_t_lt(readbytes, sizeof(expected)))
goto err;
BIO_free(in);
in = NULL;
count += bytes;
len = sizeof(buf); /* fill the buffer on subsequent reads */
}
- if (!TEST_int_eq(count, readbytes))
+ if (!TEST_size_t_eq(count, readbytes))
goto err;
ret = 1;
err:
int st = 0;
if (!TEST_ptr(ret = getBN(s, attribute))
- || !TEST_ulong_le(word = BN_get_word(ret), INT_MAX))
+ || !TEST_uint64_t_le(word = BN_get_word(ret), INT_MAX))
goto err;
*out = (int)word;
static int test_bn2padded(void)
{
uint8_t zeros[256], out[256], reference[128];
- size_t bytes;
+ int bytes;
BIGNUM *n;
int st = 0;
* The interesting stuff happens in the last bytes of the buffers,
* the beginning is just padding (i.e. sign extension).
*/
- i = sizeof(scratch) - test->mpi_len;
+ i = (int)(sizeof(scratch) - test->mpi_len);
if (!TEST_int_eq(BN_signed_bn2bin(bn, scratch, sizeof(scratch)),
sizeof(scratch))
|| !TEST_true(copy_reversed(reversed, scratch, sizeof(scratch)))
* The interesting stuff happens in the first bytes of the buffers,
* the end is just padding (i.e. sign extension).
*/
- i = sizeof(reversed) - test->mpi_len;
+ i = (int)(sizeof(reversed) - test->mpi_len);
if (!TEST_int_eq(BN_signed_bn2lebin(bn, scratch, sizeof(scratch)),
sizeof(scratch))
|| !TEST_true(copy_reversed(reversed, scratch, sizeof(scratch)))
|| !TEST_mem_eq(test->mpi, test->mpi_len, scratch, mpi_len))
goto err;
- if (!TEST_ptr(bn2 = BN_mpi2bn(scratch, mpi_len, NULL)))
+ if (!TEST_ptr(bn2 = BN_mpi2bn(scratch, (int)mpi_len, NULL)))
goto err;
if (!TEST_BN_eq(bn, bn2)) {
int setup_tests(void)
{
OPTION_CHOICE o;
- int n, stochastic = 0;
+ size_t n;
+ int stochastic = 0;
while ((o = opt_next()) != OPT_EOF) {
switch (o) {
return 0;
}
}
- n = test_get_argument_count();
+ n = test_get_argument_count();
if (!TEST_ptr(ctx = BN_CTX_new()))
return 0;
if (stochastic)
ADD_TEST(test_rand_range);
} else {
- ADD_ALL_TESTS(run_file_tests, n);
+ ADD_ALL_TESTS(run_file_tests, (int)n);
}
return 1;
}
if (currtest == TEST_SET_SESSION_TICK_DATA_VER_NEG) {
if (!TEST_true(SSL_set_session_ticket_ext(con, dummytick,
- strlen(dummytick))))
+ (int)strlen(dummytick))))
goto end;
}
},
};
-static char *pt(unsigned char *md, unsigned int len);
+static char *pt(unsigned char *md, size_t len);
static int test_cmac_bad(void)
{
}
#define OSSL_HEX_CHARS_PER_BYTE 2
-static char *pt(unsigned char *md, unsigned int len)
+static char *pt(unsigned char *md, size_t len)
{
- unsigned int i;
+ size_t i;
static char buf[81];
for (i = 0; i < len && (i + 1) * OSSL_HEX_CHARS_PER_BYTE < sizeof(buf); i++)
static int msg_total_size_log_cb(const char *func, const char *file, int line,
OSSL_CMP_severity level, const char *msg)
{
- msg_total_size += strlen(msg);
+ msg_total_size += (int)strlen(msg);
TEST_note("total=%d len=%zu msg='%s'\n", msg_total_size, strlen(msg), msg);
return 1;
}
res = 0;
} else {
ERR_raise(ERR_LIB_CMP, CMP_R_INVALID_ARGS);
- base_err_msg_size = strlen("INVALID_ARGS");
+ base_err_msg_size = (int)strlen("INVALID_ARGS");
ERR_raise(ERR_LIB_CMP, CMP_R_NULL_ARGUMENT);
- base_err_msg_size += strlen("NULL_ARGUMENT");
+ base_err_msg_size += (int)strlen("NULL_ARGUMENT");
expected_size = base_err_msg_size;
ossl_cmp_add_error_data("data1"); /* should prepend separator ":" */
- expected_size += strlen(":" "data1");
+ expected_size += (int)strlen(":" "data1");
ossl_cmp_add_error_data("data2"); /* should prepend separator " : " */
- expected_size += strlen(" : " "data2");
+ expected_size += (int)strlen(" : " "data2");
ossl_cmp_add_error_line("new line"); /* should prepend separator "\n" */
- expected_size += strlen("\n" "new line");
+ expected_size += (int)strlen("\n" "new line");
OSSL_CMP_CTX_print_errors(ctx);
if (!TEST_int_eq(msg_total_size, expected_size))
res = 0;
ERR_raise(ERR_LIB_CMP, CMP_R_INVALID_ARGS);
- base_err_msg_size = strlen("INVALID_ARGS") + strlen(":");
+ base_err_msg_size = (int)(strlen("INVALID_ARGS") + strlen(":"));
expected_size = base_err_msg_size;
while (expected_size < 4096) { /* force split */
ERR_add_error_txt(STR_SEP, max_str_literal);
- expected_size += strlen(STR_SEP) + strlen(max_str_literal);
+ expected_size += (int)(strlen(STR_SEP) + strlen(max_str_literal));
}
- expected_size += base_err_msg_size - 2 * strlen(STR_SEP);
+ expected_size += base_err_msg_size - 2 * (int)strlen(STR_SEP);
msg_total_size = 0;
OSSL_CMP_CTX_print_errors(ctx);
if (!TEST_int_eq(msg_total_size, expected_size))
static int OSSL_CMP_CTX_##SETN##_##FIELD##_str(CMP_CTX *ctx, char *val)\
{ \
return OSSL_CMP_CTX_##SETN##_##FIELD(ctx, (unsigned char *)val, \
- strlen(val)); \
+ (int)strlen(val)); \
} \
\
static char *OSSL_CMP_CTX_get1_##FIELD##_str(const CMP_CTX *ctx) \
static int test_MSG_protect_with_msg_sig_alg_protection_plus_rsa_key(void)
{
- const size_t size = sizeof(rand_data) / 2;
+ const int size = sizeof(rand_data) / 2;
SETUP_TEST_FIXTURE(CMP_PROTECT_TEST_FIXTURE, set_up);
fixture->expected = 1;
int testresult = 0;
STACK_OF(X509) *certstack = sk_X509_new_null();
const char *msg = "Hello world";
- BIO *msgbio = BIO_new_mem_buf(msg, strlen(msg));
+ BIO *msgbio = BIO_new_mem_buf(msg, (int)strlen(msg));
BIO *outmsgbio = BIO_new(BIO_s_mem());
CMS_ContentInfo* content = NULL;
BIO *contentbio = NULL;
goto end;
/* Check we got the message we first started with */
- if (!TEST_int_eq(BIO_gets(outmsgbio, buf, sizeof(buf)), strlen(msg))
+ if (!TEST_int_eq(BIO_gets(outmsgbio, buf, sizeof(buf)), (int)strlen(msg))
|| !TEST_int_eq(strcmp(buf, msg), 0))
goto end;
{
if (is_true && !TEST_size_t_eq(op(a, b), CONSTTIME_TRUE_S))
return 0;
- if (!is_true && !TEST_uint_eq(op(a, b), CONSTTIME_FALSE_S))
+ if (!is_true && !TEST_size_t_eq(op(a, b), CONSTTIME_FALSE_S))
return 0;
return 1;
}
if (a == 0 && !TEST_size_t_eq(constant_time_is_zero_s(a), CONSTTIME_TRUE_S))
return 0;
- if (a != 0 && !TEST_uint_eq(constant_time_is_zero_s(a), CONSTTIME_FALSE_S))
+ if (a != 0 && !TEST_size_t_eq(constant_time_is_zero_s(a), CONSTTIME_FALSE_S))
return 0;
return 1;
}
static int test_select_s(size_t a, size_t b)
{
- if (!TEST_uint_eq(constant_time_select_s(CONSTTIME_TRUE_S, a, b), a))
+ if (!TEST_size_t_eq(constant_time_select_s(CONSTTIME_TRUE_S, a, b), a))
return 0;
- if (!TEST_uint_eq(constant_time_select_s(CONSTTIME_FALSE_S, a, b), b))
+ if (!TEST_size_t_eq(constant_time_select_s(CONSTTIME_FALSE_S, a, b), b))
return 0;
return 1;
}
{
if (a == b && !TEST_size_t_eq(constant_time_eq_s(a, b), CONSTTIME_TRUE_S))
return 0;
- if (a != b && !TEST_int_eq(constant_time_eq_s(a, b), CONSTTIME_FALSE_S))
+ if (a != b && !TEST_size_t_eq(constant_time_eq_s(a, b), CONSTTIME_FALSE_S))
return 0;
return 1;
}
size_t s = 0;
*out = glue_strings(pem, &s);
- return BIO_new_mem_buf(*out, s);
+ return BIO_new_mem_buf(*out, (int)s);
}
/*
const unsigned char *p = data;
if (!TEST_ptr(cert = d(0, &p, len))
- || !TEST_long_eq(p - data, len)) {
+ || !TEST_long_eq((long)(p - data), len)) {
TEST_info("Certificate parsing error");
goto err;
}
if (BIO_gets(f, buf, sizeof(buf)) <= 0)
return NULL;
- n = strlen(buf);
+ n = (int)strlen(buf);
if (buf[n - 1] != '\n') {
if (n + 1 == sizeof(buf))
TEST_error("input too long");
static int passcb(char *buf, int size, int rwflag, void *userdata)
{
strcpy(buf, "pass");
- return strlen(buf);
+ return (int)strlen(buf);
}
static int test_decode_nonfipsalg(void)
memset(cbc_out, 0, sizeof(cbc_out));
memset(cbc_in, 0, sizeof(cbc_in));
memcpy(iv3, cbc_iv, sizeof(cbc_iv));
- DES_ncbc_encrypt(cbc_data, cbc_out, cbc_data_len + 1, &ks,
+ DES_ncbc_encrypt(cbc_data, cbc_out, (long)(cbc_data_len + 1), &ks,
&iv3, DES_ENCRYPT);
if (!TEST_mem_eq(cbc_out, 32, cbc_ok, 32))
return 0;
memcpy(iv3, cbc_iv, sizeof(cbc_iv));
- DES_ncbc_encrypt(cbc_out, cbc_in, cbc_data_len + 1, &ks,
+ DES_ncbc_encrypt(cbc_out, cbc_in, (long)(cbc_data_len + 1), &ks,
&iv3, DES_DECRYPT);
return TEST_mem_eq(cbc_in, cbc_data_len, cbc_data, cbc_data_len);
}
memset(cbc_out, 0, sizeof(cbc_out));
memset(cbc_in, 0, sizeof(cbc_in));
memcpy(iv3, cbc_iv, sizeof(cbc_iv));
- DES_xcbc_encrypt(cbc_data, cbc_out, n, &ks, &iv3, &cbc2_key, &cbc3_key,
+ DES_xcbc_encrypt(cbc_data, cbc_out, (long)n, &ks, &iv3, &cbc2_key, &cbc3_key,
DES_ENCRYPT);
if (!TEST_mem_eq(cbc_out, sizeof(xcbc_ok), xcbc_ok, sizeof(xcbc_ok)))
return 0;
memcpy(iv3, cbc_iv, sizeof(cbc_iv));
- DES_xcbc_encrypt(cbc_out, cbc_in, n, &ks, &iv3, &cbc2_key, &cbc3_key,
+ DES_xcbc_encrypt(cbc_out, cbc_in, (long)n, &ks, &iv3, &cbc2_key, &cbc3_key,
DES_DECRYPT);
return TEST_mem_eq(cbc_data, n, cbc_data, n);
}
DES_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3,
DES_ENCRYPT);
- DES_ede3_cbc_encrypt(&cbc_data[16], &cbc_out[16], i - 16, &ks, &ks2,
+ DES_ede3_cbc_encrypt(&cbc_data[16], &cbc_out[16], (long)(i - 16), &ks, &ks2,
&ks3, &iv3, DES_ENCRYPT);
if (!TEST_mem_eq(cbc_out, n, cbc3_ok, n))
return 0;
memcpy(iv3, cbc_iv, sizeof(cbc_iv));
- DES_ede3_cbc_encrypt(cbc_out, cbc_in, i, &ks, &ks2, &ks3, &iv3,
+ DES_ede3_cbc_encrypt(cbc_out, cbc_in, (long)i, &ks, &ks2, &ks3, &iv3,
DES_DECRYPT);
return TEST_mem_eq(cbc_in, i, cbc_data, i);
}
memcpy(iv, cbc_iv, sizeof(cbc_iv));
if (!TEST_int_eq(DES_set_key_checked(&cbc_key, &ks), 0))
return 0;
- DES_ncbc_encrypt(&cbc_data[i], cbc_out, n, &ks, &iv, DES_ENCRYPT);
+ DES_ncbc_encrypt(&cbc_data[i], cbc_out, (long)n, &ks, &iv, DES_ENCRYPT);
return 1;
}
memcpy(iv, cbc_iv, sizeof(cbc_iv));
if (!TEST_int_eq(DES_set_key_checked(&cbc_key, &ks), 0))
return 0;
- DES_ncbc_encrypt(cbc_data, &cbc_out[i], n, &ks, &iv, DES_ENCRYPT);
+ DES_ncbc_encrypt(cbc_data, &cbc_out[i], (long)n, &ks, &iv, DES_ENCRYPT);
return 1;
}
unsigned char cbc_in[40];
unsigned char cbc_out[40];
DES_key_schedule ks;
- const int n = strlen((char *)cbc_data) + 1;
+ const int n = (int)(strlen((char *)cbc_data) + 1);
if (!TEST_int_eq(DES_set_key_checked(&cbc_key, &ks), 0))
return 0;
unsigned char cret[8];
DES_set_key_checked(&cbc_key, &ks);
- cs = DES_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), &ks,
+ cs = DES_cbc_cksum(cbc_data, &cret, (long)strlen((char *)cbc_data), &ks,
&cbc_iv);
if (!TEST_cs_eq(cs, cbc_cksum_ret))
return 0;
(char *)priv, privlen))
goto err;
} else {
- privbn = BN_bin2bn(priv, privlen, NULL);
+ privbn = BN_bin2bn(priv, (int)privlen, NULL);
if (privbn == NULL)
goto err;
if (!OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_PKEY_PARAM_GROUP_NAME,
|| !TEST_ptr(dhB = td->get_param()))
goto bad_err;
- if (!TEST_ptr(priv_key = BN_bin2bn(td->xA, td->xA_len, NULL))
- || !TEST_ptr(pub_key = BN_bin2bn(td->yA, td->yA_len, NULL))
+ if (!TEST_ptr(priv_key = BN_bin2bn(td->xA, (int)td->xA_len, NULL))
+ || !TEST_ptr(pub_key = BN_bin2bn(td->yA, (int)td->yA_len, NULL))
|| !TEST_true(DH_set0_key(dhA, pub_key, priv_key)))
goto bad_err;
- if (!TEST_ptr(priv_key = BN_bin2bn(td->xB, td->xB_len, NULL))
- || !TEST_ptr(pub_key = BN_bin2bn(td->yB, td->yB_len, NULL))
+ if (!TEST_ptr(priv_key = BN_bin2bn(td->xB, (int)td->xB_len, NULL))
+ || !TEST_ptr(pub_key = BN_bin2bn(td->yB, (int)td->yB_len, NULL))
|| !TEST_true(DH_set0_key(dhB, pub_key, priv_key)))
goto bad_err;
priv_key = pub_key = NULL;
}
/* Verify again using the raw DSA interface */
- if (DSA_verify(0, dataToSign, len, signature, sigLength, dsakey) != 1) {
+ if (DSA_verify(0, dataToSign, len, signature, (int)sigLength, dsakey) != 1) {
TEST_error("Verification with unpadded data failed, len=%d", len);
goto end;
}
- if (DSA_verify(0, paddedData, digestlen, signature, sigLength, dsakey) != 1) {
+ if (DSA_verify(0, paddedData, digestlen, signature, (int)sigLength, dsakey) != 1) {
TEST_error("verify with length %d failed\n", len);
goto end;
}
for (s = mtus[0]; s <= mtus[29]; s++) {
size_t reclen;
- if (!TEST_int_eq(SSL_write(clnt_ssl, buf, s), (int)s))
+ if (!TEST_int_eq(SSL_write(clnt_ssl, buf, (int)s), (int)s))
goto end;
reclen = BIO_read(sc_bio, buf, sizeof(buf));
if (debug)
ADD_TEST(ec2m_field_sanity);
ADD_TEST(field_tests_ec2_simple);
#endif
- ADD_ALL_TESTS(field_tests_default, crv_len);
+ ADD_ALL_TESTS(field_tests_default, (int)crv_len);
#ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
ADD_TEST(underflow_test);
#endif
ADD_TEST(set_private_key);
ADD_TEST(decoded_flag_test);
- ADD_ALL_TESTS(ecpkparams_i2d2i_test, crv_len);
+ ADD_ALL_TESTS(ecpkparams_i2d2i_test, (int)crv_len);
ADD_TEST(named_group_creation_test);
return 1;
|| !TEST_int_lt(fbytes_counter, OSSL_NELEM(numbers))
|| !TEST_true(BN_hex2bn(&tmp, numbers[fbytes_counter]))
/* tmp might need leading zeros so pad it out */
- || !TEST_int_le(BN_num_bytes(tmp), num)
- || !TEST_int_gt(BN_bn2binpad(tmp, buf, num), 0))
+ || !TEST_int_le(BN_num_bytes(tmp), (int)num)
+ || !TEST_int_gt(BN_bn2binpad(tmp, buf, (int)num), 0))
goto err;
fbytes_counter = (fbytes_counter + 1) % OSSL_NELEM(numbers);
|| !TEST_true(p_len = EC_KEY_key2buf(key, POINT_CONVERSION_UNCOMPRESSED,
&pbuf, NULL))
|| !TEST_ptr(qbuf = OPENSSL_hexstr2buf(ecdsa_cavs_kats[n].Q, &q_len))
- || !TEST_int_eq(q_len, p_len)
+ || !TEST_size_t_eq((size_t)q_len, p_len)
|| !TEST_mem_eq(qbuf, q_len, pbuf, p_len))
goto err;
|| !TEST_true(EVP_DigestSignInit(mctx, NULL, NULL, NULL, pkey))
|| (as == EVP_PKEY_SM2 && !set_sm2_id(mctx, pkey))
|| !TEST_true(EVP_DigestSign(mctx, sig, &sig_len, tbs, sizeof(tbs)))
- || !TEST_int_le(sig_len, ECDSA_size(eckey))
+ || !TEST_size_t_le(sig_len, (size_t)ECDSA_size(eckey))
|| !TEST_true(EVP_MD_CTX_reset(mctx))
/* negative test, verify with wrong key, 0 return */
|| !TEST_true(EVP_DigestVerifyInit(mctx, NULL, NULL, NULL, pkey_neg))
fake_rand_finish(fake_rand);
return 0;
}
- ADD_ALL_TESTS(test_builtin_as_ec, crv_len);
+ ADD_ALL_TESTS(test_builtin_as_ec, (int)crv_len);
ADD_TEST(test_ecdsa_sig_NULL);
# ifndef OPENSSL_NO_SM2
- ADD_ALL_TESTS(test_builtin_as_sm2, crv_len);
+ ADD_ALL_TESTS(test_builtin_as_sm2, (int)crv_len);
# endif
ADD_ALL_TESTS(x9_62_tests, OSSL_NELEM(ecdsa_cavs_kats));
#endif
const BIGNUM *scalars[4];
#endif
unsigned char buf[100];
- size_t len, r = 0;
- int k;
+ size_t len;
+ int k, r = 0;
if (!TEST_ptr(ctx = BN_CTX_new())
|| !TEST_ptr(p = BN_new())
if (!TEST_int_eq(EC_GROUP_check_named_curve(group, 0, NULL), nid))
goto err;
- if (!TEST_int_eq(EC_GROUP_set_seed(group, invalid_seed, invalid_seed_len),
- invalid_seed_len))
+ if (!TEST_size_t_eq(EC_GROUP_set_seed(group, invalid_seed, invalid_seed_len),
+ invalid_seed_len))
goto err;
if (has_seed) {
goto err;
}
/* Pass if the seed is unknown (as it is optional) */
- if (!TEST_int_eq(EC_GROUP_set_seed(group, NULL, 0), 1)
+ if (!TEST_size_t_eq(EC_GROUP_set_seed(group, NULL, 0), 1)
|| !TEST_int_eq(EC_GROUP_check_named_curve(group, 0, NULL), nid))
goto err;
* An invalid seed in the parameters should be ignored: expect a "named"
* group.
*/
- if (!TEST_int_eq(EC_GROUP_set_seed(tmpg, invalid_seed, invalid_seed_len),
- invalid_seed_len)
+ if (!TEST_size_t_eq(EC_GROUP_set_seed(tmpg, invalid_seed, invalid_seed_len),
+ invalid_seed_len)
|| !TEST_ptr(other_params = *p_next++ =
EC_GROUP_get_ecparameters(tmpg, NULL))
|| !TEST_ptr(tgroup = *g_next++ =
* A null seed in the parameters should be ignored, as it is optional:
* expect a "named" group.
*/
- if (!TEST_int_eq(EC_GROUP_set_seed(tmpg, NULL, 0), 1)
+ if (!TEST_size_t_eq(EC_GROUP_set_seed(tmpg, NULL, 0), 1)
|| !TEST_ptr(other_params = *p_next++ =
EC_GROUP_get_ecparameters(tmpg, NULL))
|| !TEST_ptr(tgroup = *g_next++ =
}
static int do_test_custom_explicit_fromdata(EC_GROUP *group, BN_CTX *ctx,
- unsigned char *gen, int gen_size)
+ unsigned char *gen, size_t gen_size)
{
int ret = 0, i_out;
EVP_PKEY_CTX *pctx = NULL;
*/
static int custom_generator_test(int id)
{
- int ret = 0, nid, bsize;
+ int ret = 0, nid;
+ size_t bsize;
EC_GROUP *group = NULL;
EC_POINT *G2 = NULL, *Q1 = NULL, *Q2 = NULL;
BN_CTX *ctx = NULL;
goto err;
/* expected byte length of encoded points */
- bsize = (EC_GROUP_get_degree(group) + 7) / 8;
+ bsize = ((size_t)EC_GROUP_get_degree(group) + 7) / 8;
bsize = 1 + 2 * bsize; /* UNCOMPRESSED_POINT format */
if (!TEST_ptr(k = BN_CTX_get(ctx))
/* Q1 := kG */
|| !TEST_true(EC_POINT_mul(group, Q1, k, NULL, NULL, ctx))
/* pull out the bytes of that */
- || !TEST_int_eq(EC_POINT_point2oct(group, Q1,
- POINT_CONVERSION_UNCOMPRESSED, NULL,
- 0, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, Q1,
+ POINT_CONVERSION_UNCOMPRESSED, NULL,
+ 0, ctx), bsize)
|| !TEST_ptr(b1 = OPENSSL_malloc(bsize))
- || !TEST_int_eq(EC_POINT_point2oct(group, Q1,
- POINT_CONVERSION_UNCOMPRESSED, b1,
- bsize, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, Q1,
+ POINT_CONVERSION_UNCOMPRESSED, b1,
+ bsize, ctx), bsize)
/* new generator is G2 := 2G */
|| !TEST_true(EC_POINT_dbl(group, G2, EC_GROUP_get0_generator(group),
ctx))
|| !TEST_true(BN_rshift1(k, k))
/* Q2 := k/2 G2 */
|| !TEST_true(EC_POINT_mul(group, Q2, k, NULL, NULL, ctx))
- || !TEST_int_eq(EC_POINT_point2oct(group, Q2,
- POINT_CONVERSION_UNCOMPRESSED, NULL,
- 0, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, Q2,
+ POINT_CONVERSION_UNCOMPRESSED, NULL,
+ 0, ctx), bsize)
|| !TEST_ptr(b2 = OPENSSL_malloc(bsize))
- || !TEST_int_eq(EC_POINT_point2oct(group, Q2,
- POINT_CONVERSION_UNCOMPRESSED, b2,
- bsize, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, Q2,
+ POINT_CONVERSION_UNCOMPRESSED, b2,
+ bsize, ctx), bsize)
/* Q1 = kG = k/2 G2 = Q2 should hold */
|| !TEST_mem_eq(b1, bsize, b2, bsize))
goto err;
*/
static int custom_params_test(int id)
{
- int ret = 0, nid, bsize;
+ int ret = 0, nid;
const char *curve_name = NULL;
EC_GROUP *group = NULL, *altgroup = NULL;
EC_POINT *G2 = NULL, *Q1 = NULL, *Q2 = NULL;
EC_KEY *eckey1 = NULL, *eckey2 = NULL;
EVP_PKEY *pkey1 = NULL, *pkey2 = NULL;
EVP_PKEY_CTX *pctx1 = NULL, *pctx2 = NULL, *dctx = NULL;
- size_t sslen, t;
+ size_t sslen, t, bsize;
unsigned char *pub1 = NULL , *pub2 = NULL;
OSSL_PARAM_BLD *param_bld = NULL;
OSSL_PARAM *params1 = NULL, *params2 = NULL;
#endif
/* expected byte length of encoded points */
- bsize = (EC_GROUP_get_degree(group) + 7) / 8;
+ bsize = ((size_t)EC_GROUP_get_degree(group) + 7) / 8;
bsize = 1 + 2 * bsize; /* UNCOMPRESSED_POINT format */
/* extract parameters from built-in curve */
|| !TEST_true(EC_POINT_dbl(group, G2,
EC_GROUP_get0_generator(group), ctx))
/* pull out the bytes of that */
- || !TEST_int_eq(EC_POINT_point2oct(group, G2,
- POINT_CONVERSION_UNCOMPRESSED,
- NULL, 0, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, G2,
+ POINT_CONVERSION_UNCOMPRESSED,
+ NULL, 0, ctx), bsize)
|| !TEST_ptr(buf1 = OPENSSL_malloc(bsize))
- || !TEST_int_eq(EC_POINT_point2oct(group, G2,
- POINT_CONVERSION_UNCOMPRESSED,
- buf1, bsize, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, G2,
+ POINT_CONVERSION_UNCOMPRESSED,
+ buf1, bsize, ctx), bsize)
|| !TEST_ptr(z = EC_GROUP_get0_order(group))
|| !TEST_ptr(cof = EC_GROUP_get0_cofactor(group))
)
/* Q1 := kG on group */
|| !TEST_true(EC_POINT_mul(group, Q1, k, NULL, NULL, ctx))
/* pull out the bytes of that */
- || !TEST_int_eq(EC_POINT_point2oct(group, Q1,
- POINT_CONVERSION_UNCOMPRESSED,
- NULL, 0, ctx), bsize)
- || !TEST_int_eq(EC_POINT_point2oct(group, Q1,
- POINT_CONVERSION_UNCOMPRESSED,
- buf1, bsize, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, Q1,
+ POINT_CONVERSION_UNCOMPRESSED,
+ NULL, 0, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, Q1,
+ POINT_CONVERSION_UNCOMPRESSED,
+ buf1, bsize, ctx), bsize)
/* k := k/2 */
|| !TEST_true(BN_rshift1(k, k))
/* Q2 := k/2 G2 on altgroup */
|| !TEST_true(EC_POINT_mul(altgroup, Q2, k, NULL, NULL, ctx))
/* pull out the bytes of that */
- || !TEST_int_eq(EC_POINT_point2oct(altgroup, Q2,
- POINT_CONVERSION_UNCOMPRESSED,
- NULL, 0, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(altgroup, Q2,
+ POINT_CONVERSION_UNCOMPRESSED,
+ NULL, 0, ctx), bsize)
|| !TEST_ptr(buf2 = OPENSSL_malloc(bsize))
- || !TEST_int_eq(EC_POINT_point2oct(altgroup, Q2,
- POINT_CONVERSION_UNCOMPRESSED,
- buf2, bsize, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(altgroup, Q2,
+ POINT_CONVERSION_UNCOMPRESSED,
+ buf2, bsize, ctx), bsize)
/* Q1 = kG = k/2 G2 = Q2 should hold */
|| !TEST_mem_eq(buf1, bsize, buf2, bsize))
goto err;
* define a provider key in the built-in group.
*/
if (!TEST_true(EC_POINT_mul(group, Q1, priv1, NULL, NULL, ctx))
- || !TEST_int_eq(EC_POINT_point2oct(group, Q1,
- POINT_CONVERSION_UNCOMPRESSED,
- NULL, 0, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, Q1,
+ POINT_CONVERSION_UNCOMPRESSED,
+ NULL, 0, ctx), bsize)
|| !TEST_ptr(pub1 = OPENSSL_malloc(bsize))
- || !TEST_int_eq(EC_POINT_point2oct(group, Q1,
- POINT_CONVERSION_UNCOMPRESSED,
- pub1, bsize, ctx), bsize))
+ || !TEST_size_t_eq(EC_POINT_point2oct(group, Q1,
+ POINT_CONVERSION_UNCOMPRESSED,
+ pub1, bsize, ctx), bsize))
goto err;
/* retrieve bytes for pub2 for later */
if (!TEST_ptr(Q = EC_KEY_get0_public_key(eckey2))
- || !TEST_int_eq(EC_POINT_point2oct(altgroup, Q,
- POINT_CONVERSION_UNCOMPRESSED,
- NULL, 0, ctx), bsize)
+ || !TEST_size_t_eq(EC_POINT_point2oct(altgroup, Q,
+ POINT_CONVERSION_UNCOMPRESSED,
+ NULL, 0, ctx), bsize)
|| !TEST_ptr(pub2 = OPENSSL_malloc(bsize))
- || !TEST_int_eq(EC_POINT_point2oct(altgroup, Q,
- POINT_CONVERSION_UNCOMPRESSED,
- pub2, bsize, ctx), bsize))
+ || !TEST_size_t_eq(EC_POINT_point2oct(altgroup, Q,
+ POINT_CONVERSION_UNCOMPRESSED,
+ pub2, bsize, ctx), bsize))
goto err;
/* create two `EVP_PKEY`s from the `EC_KEY`s */
|| !TEST_int_eq(EVP_PKEY_derive_init(pctx1), 1)
|| !TEST_int_eq(EVP_PKEY_derive_set_peer(pctx1, pkey2), 1)
|| !TEST_int_eq(EVP_PKEY_derive(pctx1, NULL, &sslen), 1)
- || !TEST_int_gt(bsize, sslen)
+ || !TEST_size_t_gt(bsize, sslen)
|| !TEST_int_eq(EVP_PKEY_derive(pctx1, buf1, &sslen), 1))
goto err;
if (!TEST_ptr(pctx2 = EVP_PKEY_CTX_new(pkey2, NULL))
|| !TEST_int_eq(EVP_PKEY_derive_init(pctx2), 1)
|| !TEST_int_eq(EVP_PKEY_derive_set_peer(pctx2, pkey1), 1)
|| !TEST_int_eq(EVP_PKEY_derive(pctx2, NULL, &t), 1)
- || !TEST_int_gt(bsize, t)
- || !TEST_int_le(sslen, t)
+ || !TEST_size_t_gt(bsize, t)
+ || !TEST_size_t_le(sslen, t)
|| !TEST_int_eq(EVP_PKEY_derive(pctx2, buf2, &t), 1))
goto err;
|| !TEST_ptr(dctx = EVP_PKEY_CTX_dup(pctx1))
|| !TEST_int_eq(EVP_PKEY_derive_set_peer_ex(dctx, pkey2, 1), 1)
|| !TEST_int_eq(EVP_PKEY_derive(dctx, NULL, &t), 1)
- || !TEST_int_gt(bsize, t)
- || !TEST_int_le(sslen, t)
+ || !TEST_size_t_gt(bsize, t)
+ || !TEST_size_t_le(sslen, t)
|| !TEST_int_eq(EVP_PKEY_derive(dctx, buf1, &t), 1)
/* compare with previous result */
|| !TEST_mem_eq(buf1, t, buf2, sslen))
ADD_TEST(parameter_test);
ADD_TEST(ossl_parameter_test);
ADD_TEST(cofactor_range_test);
- ADD_ALL_TESTS(cardinality_test, crv_len);
+ ADD_ALL_TESTS(cardinality_test, (int)crv_len);
ADD_TEST(prime_field_tests);
#ifndef OPENSSL_NO_EC2M
ADD_TEST(hybrid_point_encoding_test);
ADD_ALL_TESTS(char2_curve_test, OSSL_NELEM(char2_curve_tests));
#endif
ADD_ALL_TESTS(nistp_single_test, OSSL_NELEM(nistp_tests_params));
- ADD_ALL_TESTS(internal_curve_test, crv_len);
- ADD_ALL_TESTS(internal_curve_test_method, crv_len);
+ ADD_ALL_TESTS(internal_curve_test, (int)crv_len);
+ ADD_ALL_TESTS(internal_curve_test_method, (int)crv_len);
ADD_TEST(group_field_test);
- ADD_ALL_TESTS(check_named_curve_test, crv_len);
- ADD_ALL_TESTS(check_named_curve_lookup_test, crv_len);
- ADD_ALL_TESTS(check_ec_key_field_public_range_test, crv_len);
- ADD_ALL_TESTS(check_named_curve_from_ecparameters, crv_len);
- ADD_ALL_TESTS(ec_point_hex2point_test, crv_len);
- ADD_ALL_TESTS(custom_generator_test, crv_len);
- ADD_ALL_TESTS(custom_params_test, crv_len);
+ ADD_ALL_TESTS(check_named_curve_test, (int)crv_len);
+ ADD_ALL_TESTS(check_named_curve_lookup_test, (int)crv_len);
+ ADD_ALL_TESTS(check_ec_key_field_public_range_test, (int)crv_len);
+ ADD_ALL_TESTS(check_named_curve_from_ecparameters, (int)crv_len);
+ ADD_ALL_TESTS(ec_point_hex2point_test, (int)crv_len);
+ ADD_ALL_TESTS(custom_generator_test, (int)crv_len);
+ ADD_ALL_TESTS(custom_params_test, (int)crv_len);
ADD_TEST(ec_d2i_publickey_test);
return 1;
}
|| !TEST_FL_true(OSSL_ENCODER_to_bio(ectx, mem_ser))
|| !TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
|| !TEST_FL_ptr(*encoded = mem_buf->data)
- || !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
+ || !TEST_FL_long_gt(*encoded_len = (long)mem_buf->length, 0))
goto end;
/* Detach the encoded output */
if (!TEST_FL_ptr(mem_ser = BIO_new(BIO_s_mem()))
|| !TEST_FL_true(PEM_write_bio_PrivateKey_traditional(mem_ser, pkey,
cipher,
- upass, passlen,
+ upass, (int)passlen,
NULL, NULL))
|| !TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
|| !TEST_FL_ptr(*encoded = mem_buf->data)
- || !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
+ || !TEST_FL_long_gt(*encoded_len = (long)mem_buf->length, 0))
goto end;
/* Detach the encoded output */
if (!TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
|| !TEST_FL_ptr(*encoded = mem_buf->data)
- || !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
+ || !TEST_FL_long_gt(*encoded_len = (long)mem_buf->length, 0))
goto end;
/* Detach the encoded output */
static int pass_pw(char *buf, int size, int rwflag, void *userdata)
{
OPENSSL_strlcpy(buf, userdata, size);
- return strlen(userdata);
+ return (int)strlen(userdata);
}
static int encode_EVP_PKEY_PVK(const char *file, const int line,
pass_pw, (void *)pass, testctx, testpropq), 0)
|| !TEST_FL_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
|| !TEST_FL_ptr(*encoded = mem_buf->data)
- || !TEST_FL_long_gt(*encoded_len = mem_buf->length, 0))
+ || !TEST_FL_long_gt(*encoded_len = (long)mem_buf->length, 0))
goto end;
/* Detach the encoded output */
{
const unsigned char *datap = data;
PKCS8_PRIV_KEY_INFO *p8inf =
- d2i_PKCS8_PRIV_KEY_INFO(NULL, &datap, data_len);
+ d2i_PKCS8_PRIV_KEY_INFO(NULL, &datap, (long)data_len);
int ok = 0;
if (TEST_FL_ptr(p8inf)) {
itype = EVP_PKEY_EC;
if (itype != NID_undef) {
- pkey = d2i_KeyParams(itype, NULL, &datap, data_len);
+ pkey = d2i_KeyParams(itype, NULL, &datap, (long)data_len);
ok = (pkey != NULL);
EVP_PKEY_free(pkey);
}
const char *type, const void *data, size_t data_len)
{
const unsigned char *datap = data;
- EVP_PKEY *pkey = b2i_PrivateKey(&datap, data_len);
+ EVP_PKEY *pkey = b2i_PrivateKey(&datap, (long)data_len);
int ok = TEST_FL_ptr(pkey);
EVP_PKEY_free(pkey);
unsigned int saltlen = 0, keylen = 0;
int isdss = -1;
- return ossl_do_PVK_header(&in, data_len, 0, &isdss, &saltlen, &keylen);
+ return ossl_do_PVK_header(&in, (unsigned int)data_len, 0, &isdss, &saltlen,
+ &keylen);
}
static int test_unprotected_via_PVK(const char *type, EVP_PKEY *key)
const void *data, size_t data_len)
{
const unsigned char *datap = data;
- X509_SIG *p8 = d2i_X509_SIG(NULL, &datap, data_len);
+ X509_SIG *p8 = d2i_X509_SIG(NULL, &datap, (long)data_len);
int ok = TEST_FL_ptr(p8);
X509_SIG_free(p8);
const char *type, const void *data, size_t data_len)
{
const unsigned char *datap = data;
- EVP_PKEY *pkey = d2i_PUBKEY_ex(NULL, &datap, data_len, testctx, testpropq);
+ EVP_PKEY *pkey = d2i_PUBKEY_ex(NULL, &datap, (long)data_len, testctx,
+ testpropq);
int ok = (TEST_FL_ptr(pkey) && TEST_FL_true(EVP_PKEY_is_a(pkey, type)));
EVP_PKEY_free(pkey);
const void *data, size_t data_len)
{
const unsigned char *datap = data;
- EVP_PKEY *pkey = b2i_PublicKey(&datap, data_len);
+ EVP_PKEY *pkey = b2i_PublicKey(&datap, (long)data_len);
int ok = TEST_FL_ptr(pkey);
EVP_PKEY_free(pkey);
#ifdef OPENSSL_NO_ENGINE
TEST_note("No ENGINE support");
#else
- int n;
+ size_t n;
if (!test_skip_common_options()) {
TEST_error("Error parsing test options\n");
goto err;
/* Positive and negative testcase for EVP_PKEY_get1_encoded_public_key */
- if (!TEST_int_gt(EVP_PKEY_get1_encoded_public_key(params_and_pub, &encoded), 0))
+ if (!TEST_size_t_gt(EVP_PKEY_get1_encoded_public_key(params_and_pub, &encoded), 0))
goto err;
OPENSSL_free(encoded);
encoded = NULL;
- if (!TEST_int_eq(EVP_PKEY_get1_encoded_public_key(just_params, &encoded), 0)) {
+ if (!TEST_size_t_eq(EVP_PKEY_get1_encoded_public_key(just_params, &encoded), 0)) {
OPENSSL_free(encoded);
encoded = NULL;
goto err;
if (!TEST_int_eq(EVP_PKEY_get_octet_string_param(params_and_pub,
OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY,
buffer, sizeof(buffer), &len), 1)
- || !TEST_int_eq(len, 65))
+ || !TEST_size_t_eq(len, 65))
goto err;
len = 0;
if (!TEST_int_eq(EVP_PKEY_get_octet_string_param(params_and_pub,
OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY,
NULL, 0, &len), 1)
- || !TEST_int_eq(len, 65))
+ || !TEST_size_t_eq(len, 65))
goto err;
/* too-short buffer len*/
int expected_id = ak->evptype;
p = input;
- if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
+ if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, (long)input_len))
|| !TEST_ptr_eq(p, input + input_len)
|| !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
goto done;
/* Can we parse PKCS#8 v2, ignoring the public key for now? */
p = input;
- p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &p, input_len);
+ p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &p, (long)input_len);
if (!TEST_ptr(p8inf)
|| !TEST_true(p == input + input_len))
goto done;
EVP_PKEY_CTX *pctx = NULL;
EVP_MD *sm3 = NULL;
- bio = BIO_new_mem_buf(pubkey, strlen(pubkey));
+ bio = BIO_new_mem_buf(pubkey, (int)strlen(pubkey));
if (!TEST_true(bio != NULL))
goto done;
if (!TEST_true(EVP_DigestVerifyInit(mctx, NULL, sm3, NULL, pkey)))
goto done;
- if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, id, strlen(id)), 0))
+ if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, id, (int)strlen(id)), 0))
goto done;
if (!TEST_true(EVP_DigestVerifyUpdate(mctx, msg, strlen(msg))))
#ifndef OPENSSL_NO_ML_KEM
static int
-ml_kem_seed_to_priv(const char *alg, const unsigned char *seed, int seedlen,
+ml_kem_seed_to_priv(const char *alg, const unsigned char *seed, size_t seedlen,
unsigned char **ret, size_t *retlen)
{
OSSL_PARAM parr[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
if (!TEST_ptr(xp))
goto done;
- if (!TEST_ptr(d2i_X509_PUBKEY(&xp, &p, input_len)))
+ if (!TEST_ptr(d2i_X509_PUBKEY(&xp, &p, (long)input_len)))
goto done;
if (!TEST_ptr(X509_PUBKEY_get0(xp)))
p = kExampleBadECPubKeyDER;
input_len = sizeof(kExampleBadECPubKeyDER);
- if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len)))
+ if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, (long)input_len)))
goto done;
if (!TEST_true(X509_PUBKEY_get0(xp) == NULL))
xp = X509_PUBKEY_new_ex(testctx, testpropq);
if (!TEST_ptr(xp)
- || !TEST_ptr(d2i_X509_PUBKEY(&xp, &p, input_len))
+ || !TEST_ptr(d2i_X509_PUBKEY(&xp, &p, (long)input_len))
|| !TEST_ptr(xq = X509_PUBKEY_dup(xp))
|| !TEST_ptr_ne(xp, xq))
goto done;
p = kExampleBadECPubKeyDER;
input_len = sizeof(kExampleBadECPubKeyDER);
- if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len))
+ if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, (long)input_len))
|| !TEST_ptr(xq = X509_PUBKEY_dup(xp)))
goto done;
goto err;
ivlen = EVP_CIPHER_CTX_get_iv_length(ctx);
- if (!TEST_int_gt(ivlen, 0))
+ if (!TEST_size_t_gt(ivlen, 0))
goto err;
if (!TEST_mem_eq(init_iv, ivlen, oiv, ivlen)
goto err;
ivlen = EVP_CIPHER_CTX_get_iv_length(ctx);
- if (!TEST_int_gt(ivlen, 0))
+ if (!TEST_size_t_gt(ivlen, 0))
goto err;
if (!TEST_mem_eq(init_iv, ivlen, oiv, ivlen)
int res = 0;
if (t->ivlen != 0) {
- if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, t->ivlen, NULL), 0))
+ if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN,
+ (int)t->ivlen, NULL), 0))
goto err;
}
if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, NULL, t->iv, -1)))
errmsg = "FINAL_ENC_INIT";
goto err;
}
- if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, t->inlen))) {
+ if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, (int)t->inlen))) {
errmsg = "CIPHER_UPDATE";
goto err;
}
if (t->finalenc == 0 && t->tag != NULL) {
/* Set expected tag */
if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
- t->taglen, (void *)t->tag), 0)) {
+ (int)t->taglen, (void *)t->tag), 0)) {
errmsg = "SET_TAG";
goto err;
}
goto err;
}
if (t->finalenc != 0 && t->tag != NULL) {
- if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag), 0)) {
+ if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
+ (int)taglen, tag), 0)) {
errmsg = "GET_TAG";
goto err;
}
/* setup cipher context */
|| !TEST_true(EVP_CipherInit_ex2(ctx, type, t->key, t->iv, t->initenc, NULL))
/* first iteration */
- || !TEST_true(EVP_CipherUpdate(ctx, outbuf1, &outlen1, t->input, t->inlen))
+ || !TEST_true(EVP_CipherUpdate(ctx, outbuf1, &outlen1, t->input,
+ (int)t->inlen))
|| !TEST_true(EVP_CipherFinal_ex(ctx, outbuf1, &outlen_final))
/* check test results iteration 1 */
|| !TEST_mem_eq(t->expected, t->expectedlen, outbuf1, outlen1 + outlen_final)
/* now re-init the context (same cipher, key and iv) */
|| !TEST_true(EVP_CipherInit_ex2(ctx, NULL, NULL, NULL, -1, NULL))
/* second iteration */
- || !TEST_true(EVP_CipherUpdate(ctx, outbuf2, &outlen2, t->input, t->inlen))
+ || !TEST_true(EVP_CipherUpdate(ctx, outbuf2, &outlen2,
+ t->input, (int)t->inlen))
|| !TEST_true(EVP_CipherFinal_ex(ctx, outbuf2, &outlen_final))
/* check test results iteration 2 */
|| !TEST_mem_eq(t->expected, t->expectedlen, outbuf2, outlen2 + outlen_final))
errmsg = "PADDING";
goto err;
}
- if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, t->inlen))) {
+ if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1,
+ t->input, (int)t->inlen))) {
errmsg = "CIPHER_UPDATE";
goto err;
}
errmsg = "CIPHER_REINIT";
goto err;
}
- if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, t->inlen))) {
+ if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1,
+ t->input, (int)t->inlen))) {
errmsg = "CIPHER_UPDATE (reinit)";
goto err;
}
errmsg = "ENC_INIT";
goto err;
}
- if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, t->ivlen1, NULL), 0)) {
+ if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN,
+ (int)t->ivlen1, NULL), 0)) {
errmsg = "SET_IVLEN1";
goto err;
}
errmsg = "WRONG_RESULT1";
goto err;
}
- if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag), 0)) {
+ if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
+ (int)taglen, tag), 0)) {
errmsg = "GET_TAG1";
goto err;
}
goto err;
}
/* Now reinit */
- if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, t->ivlen2, NULL), 0)) {
+ if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN,
+ (int)t->ivlen2, NULL), 0)) {
errmsg = "SET_IVLEN2";
goto err;
}
errmsg = "WRONG_RESULT2";
goto err;
}
- if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag), 0)) {
+ if (!TEST_int_gt(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
+ (int)taglen, tag), 0)) {
errmsg = "GET_TAG2";
goto err;
}
if (!TEST_true(EVP_EncryptInit_ex2(ctx, cipher, gcm_key, gcm_iv, params))
|| (gcm_aad != NULL
&& !TEST_true(EVP_EncryptUpdate(ctx, NULL, &outlen,
- gcm_aad, gcm_aad_s)))
+ gcm_aad, (int)gcm_aad_s)))
|| !TEST_true(EVP_EncryptUpdate(ctx, outbuf, &outlen,
- gcm_pt, gcm_pt_s))
+ gcm_pt, (int)gcm_pt_s))
|| !TEST_true(EVP_EncryptFinal_ex(ctx, outbuf, &tmplen)))
goto err;
if (!TEST_true(EVP_DecryptInit_ex2(ctx, cipher, gcm_key, gcm_iv, params))
|| (gcm_aad != NULL
&& !TEST_true(EVP_DecryptUpdate(ctx, NULL, &outlen,
- gcm_aad, gcm_aad_s)))
+ gcm_aad, (int)gcm_aad_s)))
|| !TEST_true(EVP_DecryptUpdate(ctx, outbuf, &outlen,
- gcm_ct, gcm_ct_s))
+ gcm_ct, (int)gcm_ct_s))
|| !TEST_mem_eq(outbuf, outlen, gcm_pt, gcm_pt_s))
goto err;
if (!TEST_true(EVP_EncryptInit_ex2(ctx, cipher, rc4_key, NULL, params))
|| !TEST_true(EVP_EncryptUpdate(ctx, outbuf, &outlen,
- rc4_pt, rc4_pt_s))
+ rc4_pt, (int)rc4_pt_s))
|| !TEST_true(EVP_EncryptFinal_ex(ctx, outbuf, &tmplen)))
goto err;
if (!TEST_true(EVP_DecryptInit_ex2(ctx, cipher, rc4_key, NULL, params))
|| !TEST_true(EVP_DecryptUpdate(ctx, outbuf, &outlen,
- rc4_ct, rc4_ct_s))
+ rc4_ct, (int)rc4_ct_s))
|| !TEST_mem_eq(outbuf, outlen, rc4_pt, rc4_pt_s))
goto err;
|| !TEST_ptr(tag_array[i] = OPENSSL_malloc(taglen)))
goto err;
- memset(iv_array[i], i + 33, ivlen);
- memset(plaintext_array[i], i + 1, plaintextlen);
+ memset(iv_array[i], (unsigned char)(i + 33), ivlen);
+ memset(plaintext_array[i], (unsigned char)(i + 1), plaintextlen);
inlen_array[i] = plaintextlen;
outlen_array[i] = 0;
ciphertextlen_array[i] = 0;
if (!TEST_true(EVP_EncryptInit(ctx, cipher, key, iv_array[i]))
|| !TEST_true(EVP_EncryptUpdate(ctx, NULL, &outlen,
plaintext_array[i],
- plaintextlen))
+ (int)plaintextlen))
|| !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &outlen,
plaintext_array[i],
- plaintextlen)))
+ (int)plaintextlen)))
goto err;
ciphertextlen = outlen;
goto err;
for (i = 0; i < numpipes; i++) {
- memset(exp_plaintext, i + 1, plaintextlen);
+ memset(exp_plaintext, (unsigned char)(i + 1), plaintextlen);
if (!TEST_mem_eq(plaintext_array[i], plaintextlen,
exp_plaintext, plaintextlen))
goto err;
BIGNUM *priv_bn = NULL;
p = input;
- if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &p, input_len, mainctx,
- NULL))
+ if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &p, (long)input_len,
+ mainctx, NULL))
|| !TEST_ptr_eq(p, input + input_len)
|| !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
goto done;
if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
goto err;
- if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[id].kder, keydata[id].size)))
+ if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[id].kder, (int)keydata[id].size)))
goto err;
if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
goto err;
BIO *key_bio = NULL;
EVP_PKEY *pkey = NULL;
- if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[testid].kder, keydata[testid].size)))
+ if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[testid].kder,
+ (int)keydata[testid].size)))
goto err;
ERR_clear_error();
if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
ret = TEST_ptr(p = OSSL_PARAM_locate(params, key))
&& TEST_true(OSSL_PARAM_get_BN(p, &bn))
- && TEST_int_gt(len = BN_bn2binpad(bn, buffer, expected_len), 0)
+ && TEST_int_gt(len = BN_bn2binpad(bn, buffer, (int)expected_len), 0)
&& TEST_mem_eq(expected, expected_len, buffer, len);
BN_free(bn);
return ret;
int ret = 0;
const unsigned char *pdata = keydata[0].kder;
- ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
+ ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, (long)keydata[0].size,
mainctx, NULL))
&& TEST_int_eq(EVP_PKEY_todata(NULL, EVP_PKEY_KEYPAIR, ¶ms), 0)
&& TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, NULL), 0);
int ret = 0;
const unsigned char *pdata = keydata[0].kder;
- ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
+ ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, (long)keydata[0].size,
mainctx, NULL))
&& TEST_int_eq(EVP_PKEY_export(NULL, EVP_PKEY_KEYPAIR,
test_pkey_export_cb, NULL), 0)
#endif
int ret = 1;
const unsigned char *pdata = keydata[0].kder;
- int pdata_len = keydata[0].size;
+ int pdata_len = (int)keydata[0].size;
if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
mainctx, NULL))
#ifndef OPENSSL_NO_DEPRECATED_3_0
/* Now, try with a legacy key */
pdata = keydata[0].kder;
- pdata_len = keydata[0].size;
+ pdata_len = (int)keydata[0].size;
if (!TEST_ptr(pkey = EVP_PKEY_new())
|| !TEST_ptr(rsa = d2i_RSAPrivateKey(NULL, &pdata, pdata_len))
|| !TEST_true(EVP_PKEY_set1_RSA(pkey, rsa))
(char *)mdname, 0);
sig_params[2] = OSSL_PARAM_construct_end();
- ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
+ ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, (long)keydata[0].size,
mainctx, NULL))
&& TEST_ptr(pctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
&& TEST_int_gt(EVP_PKEY_sign_init_ex(pctx, sig_params), 0)
&& TEST_int_gt(EVP_PKEY_sign(pctx, NULL, &sig_len, mdbuf,
sizeof(mdbuf)), 0)
- && TEST_int_gt(sig_len, 0)
+ && TEST_size_t_gt(sig_len, 0)
&& TEST_ptr(sig = OPENSSL_malloc(sig_len))
&& TEST_int_gt(EVP_PKEY_sign(pctx, sig, &sig_len, mdbuf,
sizeof(mdbuf)), 0);
memset(key, 0, sizeof(key));
if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
|| !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, key, NULL, 1))
- || !TEST_true(EVP_CipherUpdate(ctx, ct, &ctlen, msg, len))
+ || !TEST_true(EVP_CipherUpdate(ctx, ct, &ctlen, msg, (int)len))
|| !TEST_true(EVP_CipherFinal_ex(ctx, ct, &ctlen))
|| !TEST_true(EVP_CipherInit_ex(ctx, cipher, NULL, key, NULL, 0))
|| !TEST_true(EVP_CipherUpdate(ctx, pt, &ptlen, ct, ctlen))
|| !TEST_true(OSSL_ENCODER_to_data(ectx, &pub_der, &len)))
goto err;
pp = pub_der;
- if (!TEST_ptr(d2i_PublicKey(EVP_PKEY_RSA, pub, &pp, len)))
+ if (!TEST_ptr(d2i_PublicKey(EVP_PKEY_RSA, pub, &pp, (long)len)))
goto err;
ret = 1;
err:
&& TEST_int_eq(EVP_PKEY_encapsulate(dctx, NULL, NULL, NULL, NULL), 0)
&& TEST_int_eq(EVP_PKEY_encapsulate(dctx, NULL, &ctlen, NULL,
&secretlen), 1)
- && TEST_int_eq(ctlen, secretlen)
- && TEST_int_eq(ctlen, bits / 8)
+ && TEST_size_t_eq(ctlen, secretlen)
+ && TEST_size_t_eq(ctlen, bits / 8)
&& TEST_int_eq(EVP_PKEY_encapsulate(dctx, ct, &ctlen, secret,
&secretlen), 1)
&& TEST_ptr(rctx = EVP_PKEY_CTX_new_from_pkey(libctx, priv, NULL))
&& TEST_int_eq(EVP_PKEY_CTX_set_kem_op(privctx, "RSASVE"), 1)
&& TEST_int_eq(EVP_PKEY_decapsulate(privctx, secret, NULL, ct, sizeof(ct)), 1)
&& TEST_int_eq(EVP_PKEY_decapsulate(privctx, NULL, &secretlen, ct, sizeof(ct)), 1)
- && TEST_int_eq(secretlen, 256)
+ && TEST_size_t_eq(secretlen, 256)
/* Fail if passed NULL arguments */
&& TEST_int_eq(EVP_PKEY_decapsulate(privctx, NULL, NULL, ct, sizeof(ct)), 0)
&& TEST_int_eq(EVP_PKEY_decapsulate(privctx, secret, &secretlen, NULL, 0), 0)
const TEST_DERIVEKEY_DATA *t = &ec_derivekey_data[tstid];
unsigned char pubkey[133];
unsigned char privkey[66];
- size_t pubkeylen = 0, privkeylen = 0;
+ size_t pubkeylen = 0;
+ int privkeylen = 0;
BIGNUM *priv = NULL;
params[0] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
if (!test_duplicate_md_ctx(t, EVP_MD_CTX_dup(mctx)))
goto err;
- got_len = expected->output_len;
- if (!EVP_DigestFinalXOF(mctx, got, got_len)) {
+ got_len = (unsigned int)expected->output_len;
+ if (!EVP_DigestFinalXOF(mctx, got, expected->output_len)) {
t->err = "DIGESTFINALXOF_ERROR";
goto err;
}
goto err;
}
}
- if (!TEST_int_eq(expected->output_len, got_len)) {
+ if (!TEST_size_t_eq(expected->output_len, got_len)) {
t->err = "DIGEST_LENGTH_MISMATCH";
goto err;
}
if (expected->iv) {
if (expected->aead) {
if (EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_AEAD_SET_IVLEN,
- expected->iv_len, 0) <= 0) {
+ (int)expected->iv_len, 0) <= 0) {
t->err = "INVALID_IV_LENGTH";
goto err;
}
}
if (tag || expected->aead != EVP_CIPH_GCM_MODE) {
if (EVP_CIPHER_CTX_ctrl(ctx_base, EVP_CTRL_AEAD_SET_TAG,
- expected->tag_len, tag) <= 0)
+ (int)expected->tag_len, tag) <= 0)
goto err;
}
}
}
}
- if (!EVP_CIPHER_CTX_set_key_length(ctx_base, expected->key_len)) {
+ if (!EVP_CIPHER_CTX_set_key_length(ctx_base, (int)expected->key_len)) {
t->err = "INVALID_KEY_LENGTH";
goto err;
}
}
if (expected->aead == EVP_CIPH_CCM_MODE) {
- if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
+ if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, (int)out_len)) {
t->err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
goto err;
}
donelen = 0;
do {
- size_t current_aad_len = (size_t) data_chunk_size;
+ size_t current_aad_len = (size_t)data_chunk_size;
- if (data_chunk_size == 0 || (size_t) data_chunk_size > aad_len)
+ if (data_chunk_size == 0 || current_aad_len > aad_len)
current_aad_len = aad_len;
if (!EVP_CipherUpdate(ctx, NULL, &chunklen,
expected->aad[i] + donelen,
- current_aad_len))
+ (int)current_aad_len))
goto err;
donelen += current_aad_len;
aad_len -= current_aad_len;
if (expected->aad_len[i] > 2) {
if (!EVP_CipherUpdate(ctx, NULL, &chunklen,
expected->aad[i] + donelen,
- expected->aad_len[i] - 2))
+ (int)(expected->aad_len[i] - 2)))
goto err;
donelen += expected->aad_len[i] - 2;
}
} else if (!enc && (expected->aead == EVP_CIPH_OCB_MODE
|| expected->tag_late)) {
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
- expected->tag_len, expected->tag) <= 0) {
+ (int)expected->tag_len, expected->tag) <= 0) {
t->err = "TAG_SET_ERROR";
goto err;
}
} else if (!enc && expected->mac_key && expected->tag) {
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
- expected->tag_len, expected->tag) <= 0) {
+ (int)expected->tag_len, expected->tag) <= 0) {
t->err = "TAG_SET_ERROR";
goto err;
}
if (!frag) {
do {
/* Supply the data all in one go or according to data_chunk_size */
- size_t current_in_len = (size_t) data_chunk_size;
+ size_t current_in_len = (size_t)data_chunk_size;
- if (data_chunk_size == 0 || (size_t) data_chunk_size > in_len)
+ if (data_chunk_size == 0 || current_in_len > in_len)
current_in_len = in_len;
if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
- in, current_in_len))
+ in, (int)current_in_len))
goto err;
tmplen += chunklen;
in += current_in_len;
}
if (in_len > 1) {
if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
- in, in_len - 1))
+ in, (int)(in_len - 1)))
goto err;
tmplen += chunklen;
in += in_len - 1;
if (expected->tls_version >= TLS1_1_VERSION
&& (EVP_CIPHER_is_a(expected->cipher, "AES-128-CBC-HMAC-SHA1")
|| EVP_CIPHER_is_a(expected->cipher, "AES-256-CBC-HMAC-SHA1"))) {
- tmplen -= expected->iv_len;
+ tmplen -= (int)expected->iv_len;
expected_out += expected->iv_len;
out_misalign += expected->iv_len;
}
goto err;
}
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
- expected->tag_len, rtag) <= 0) {
+ (int)expected->tag_len, rtag) <= 0) {
t->err = "TAG_RETRIEVE_ERROR";
goto err;
}
goto err;
}
if (expected->pbe_type == PBE_TYPE_PBKDF2) {
- if (PKCS5_PBKDF2_HMAC((char *)expected->pass, expected->pass_len,
- expected->salt, expected->salt_len,
+ if (PKCS5_PBKDF2_HMAC((char *)expected->pass, (int)expected->pass_len,
+ expected->salt, (int)expected->salt_len,
expected->iter, expected->md,
- expected->key_len, key) == 0) {
+ (int)expected->key_len, key) == 0) {
t->err = "PBKDF2_ERROR";
goto err;
}
t->err = "PKCS12_ERROR";
goto err;
}
- if (PKCS12_key_gen_uni(expected->pass, expected->pass_len,
- expected->salt, expected->salt_len,
- expected->id, expected->iter, expected->key_len,
+ if (PKCS12_key_gen_uni(expected->pass, (int)expected->pass_len,
+ expected->salt, (int)expected->salt_len,
+ expected->id, expected->iter, (int)expected->key_len,
key, fetched_digest) == 0) {
t->err = "PKCS12_ERROR";
goto err;
donelen = 0;
output_len = 0;
do {
- size_t current_len = (size_t) data_chunk_size;
+ size_t current_len = (size_t)data_chunk_size;
- if (data_chunk_size == 0 || (size_t) data_chunk_size > input_len)
+ if (data_chunk_size == 0 || current_len > input_len)
current_len = input_len;
if (!TEST_true(EVP_EncodeUpdate(encode_ctx, encode_out, &chunk_len,
expected->input + donelen,
- current_len)))
+ (int)current_len)))
goto err;
donelen += current_len;
input_len -= current_len;
if (data_chunk_size == 0 || (size_t) data_chunk_size > input_len)
current_len = input_len;
if (EVP_DecodeUpdate(decode_ctx, decode_out + output_len, &chunk_len,
- expected->output + donelen, current_len) < 0) {
+ expected->output + donelen, (int)current_len) < 0) {
t->err = "DECODE_ERROR";
goto err;
}
if (n == 0)
return 0;
- ADD_ALL_TESTS(run_file_tests, n);
+ ADD_ALL_TESTS(run_file_tests, (int)n);
return 1;
}
if (!TEST_int_eq(EVP_MD_CTX_size(ctx), -1)
|| !TEST_int_eq(EVP_MD_CTX_set_params(ctx, params), 1)
- || !TEST_int_eq(EVP_MD_CTX_size(ctx), sz)
+ || !TEST_int_eq(EVP_MD_CTX_size(ctx), (int)sz)
|| !TEST_int_eq(EVP_MD_get_size(md), 0)
|| !TEST_true(EVP_MD_xof(md))
|| !TEST_true(EVP_DigestUpdate(ctx, shake256_input,
*siglen = 256;
/* record that the real sign operation was called */
if (sig != NULL) {
- if (!TEST_int_ge(sigsize, *siglen))
+ if (!TEST_size_t_ge(sigsize, *siglen))
return 0;
*sigctx = 2;
/* produce a fake signature */
*siglen = 256;
/* record that the real sign operation was called */
if (sig != NULL) {
- if (!TEST_int_ge(sigsize, *siglen))
+ if (!TEST_size_t_ge(sigsize, *siglen))
return 0;
/* produce a fake signature */
memset(sig, 'a', *siglen);
TEST_error("Unexpected success reading data: %s\n", buf);
goto err;
}
- if (!TEST_int_le(SSL_write(sssl, msg, strlen(msg)), 0))
+ if (!TEST_int_le(SSL_write(sssl, msg, (int)strlen(msg)), 0))
goto err;
ret = 1;
{
char *config_file = NULL;
OPTION_CHOICE o;
- int n;
+ size_t n;
while ((o = opt_next()) != OPT_EOF) {
switch (o) {
if (n == 0)
return 0;
- ADD_ALL_TESTS(test_fips_version, n);
+ ADD_ALL_TESTS(test_fips_version, (int)n);
return 1;
}
i = prefix + 1;
while (i <= len) {
if ((*out)[i] == ',') {
- if (!TEST_int_gt(i - 1, prefix))
+ if (!TEST_size_t_gt(i - 1, prefix))
goto err;
(*out)[prefix] = (unsigned char)(i - 1 - prefix);
prefix = i;
}
i++;
}
- if (!TEST_int_gt(len, prefix))
+ if (!TEST_size_t_gt(len, prefix))
goto err;
(*out)[prefix] = (unsigned char)(len - prefix);
return 1;
ret = SSL_select_next_proto(out, outlen, in, inlen,
ctx_data->npn_protocols,
- ctx_data->npn_protocols_len);
+ (unsigned int)ctx_data->npn_protocols_len);
/* Accept both OPENSSL_NPN_NEGOTIATED and OPENSSL_NPN_NO_OVERLAP. */
return TEST_true(ret == OPENSSL_NPN_NEGOTIATED || ret == OPENSSL_NPN_NO_OVERLAP)
? SSL_TLSEXT_ERR_OK : SSL_TLSEXT_ERR_ALERT_FATAL;
{
CTX_DATA *ctx_data = (CTX_DATA*)(arg);
*data = ctx_data->npn_protocols;
- *len = ctx_data->npn_protocols_len;
+ *len = (unsigned int)ctx_data->npn_protocols_len;
return SSL_TLSEXT_ERR_OK;
}
#endif
*/
ret = SSL_select_next_proto(&tmp_out, outlen,
ctx_data->alpn_protocols,
- ctx_data->alpn_protocols_len, in, inlen);
+ (unsigned int)ctx_data->alpn_protocols_len, in, inlen);
*out = tmp_out;
/* Unlike NPN, we don't tolerate a mismatch. */
CTX_DATA *client_ctx_data)
{
unsigned char *ticket_keys;
- size_t ticket_key_len;
+ long ticket_key_len;
if (!TEST_int_eq(SSL_CTX_set_max_send_fragment(server_ctx,
test->max_fragment_size), 1))
&alpn_protos, &alpn_protos_len))
/* Reversed return value convention... */
|| !TEST_int_eq(SSL_CTX_set_alpn_protos(client_ctx, alpn_protos,
- alpn_protos_len), 0))
+ (unsigned int)alpn_protos_len), 0))
goto err;
OPENSSL_free(alpn_protos);
}
*/
ticket_key_len = SSL_CTX_set_tlsext_ticket_keys(server_ctx, NULL, 0);
if (!TEST_ptr(ticket_keys = OPENSSL_zalloc(ticket_key_len))
- || !TEST_int_eq(SSL_CTX_set_tlsext_ticket_keys(server_ctx,
- ticket_keys,
- ticket_key_len), 1)) {
+ || !TEST_long_eq(SSL_CTX_set_tlsext_ticket_keys(server_ctx,
+ ticket_keys,
+ ticket_key_len), 1)) {
OPENSSL_free(ticket_keys);
goto err;
}
else
md = EVP_MD_fetch(test_ctx, OBJ_nid2sn(mac->nid), test_propq);
- if (!TEST_true(PKCS12_set_mac(p12, mac->pass, strlen(mac->pass),
+ if (!TEST_true(PKCS12_set_mac(p12, mac->pass, (int)strlen(mac->pass),
NULL, 0, mac->iter, md))) {
pb->success = 0;
goto err;
static int check_p12_mac(PKCS12 *p12, const PKCS12_ENC *mac)
{
return TEST_true(PKCS12_mac_present(p12))
- && TEST_true(PKCS12_verify_mac(p12, mac->pass, strlen(mac->pass)));
+ && TEST_true(PKCS12_verify_mac(p12, mac->pass, (int)strlen(mac->pass)));
}
if (enc) {
if (!TEST_int_eq(bagnid, NID_pkcs7_encrypted))
goto err;
- bags = PKCS12_unpack_p7encdata(p7, enc->pass, strlen(enc->pass));
+ bags = PKCS12_unpack_p7encdata(p7, enc->pass, (int)strlen(enc->pass));
} else {
if (!TEST_int_eq(bagnid, NID_pkcs7_data))
goto err;
goto err;
} else if (attr_nid == NID_localKeyID) {
if (!TEST_true(PKCS12_add_localkeyid(bag, (unsigned char *)p_attr->value,
- strlen(p_attr->value))))
+ (int)strlen(p_attr->value))))
goto err;
} else if (attr_nid == NID_oracle_jdk_trustedkeyusage) {
attrs = (STACK_OF(X509_ATTRIBUTE)*)PKCS12_SAFEBAG_get0_attrs(bag);
/* Custom attribute values limited to ASCII in these tests */
if (!TEST_true(PKCS12_add1_attr_by_txt(bag, p_attr->oid, MBSTRING_ASC,
(unsigned char *)p_attr->value,
- strlen(p_attr->value))))
+ (int)strlen(p_attr->value))))
goto err;
}
p_attr++;
TEST_info("Adding secret <%s>", secret);
- bag = PKCS12_add_secret(&pb->bags, secret_nid, (const unsigned char *)secret, strlen(secret));
+ bag = PKCS12_add_secret(&pb->bags, secret_nid,
+ (const unsigned char *)secret, (int)strlen(secret));
if (!TEST_ptr(bag)) {
pb->success = 0;
return;
case NID_pkcs8ShroudedKeyBag:
if (legacy)
- p8 = PKCS12_decrypt_skey(bag, enc->pass, strlen(enc->pass));
+ p8 = PKCS12_decrypt_skey(bag, enc->pass, (int)strlen(enc->pass));
else
- p8 = PKCS12_decrypt_skey_ex(bag, enc->pass, strlen(enc->pass), test_ctx, test_propq);
+ p8 = PKCS12_decrypt_skey_ex(bag, enc->pass, (int)strlen(enc->pass),
+ test_ctx, test_propq);
if (!TEST_ptr(p8)) {
pb->success = 0;
goto err;
EVP_PKEY *dhpkey = NULL;
BIGNUM *p = NULL, *g = NULL, *q = NULL;
- p = BN_bin2bn(pdata, plen, NULL);
- g = BN_bin2bn(gdata, glen, NULL);
+ p = BN_bin2bn(pdata, (int)plen, NULL);
+ g = BN_bin2bn(gdata, (int)glen, NULL);
if (p == NULL || g == NULL)
goto err;
- if (qdata != NULL && (q = BN_bin2bn(qdata, qlen, NULL)) == NULL)
+ if (qdata != NULL && (q = BN_bin2bn(qdata, (int)qlen, NULL)) == NULL)
goto err;
dhpkey = get_dh_from_pg_bn(libctx, type, p, g, q);
* 14 long header (we assume token length is 0,
* which is fine for server not so fine for client)
*/
- grow_allowance = 1200 - bufsz - 16 - 14;
+ grow_allowance = 1200 - (int)bufsz - 16 - 14;
grow_allowance -= hdrin->dst_conn_id.id_len;
grow_allowance -= hdrin->src_conn_id.id_len;
assert(grow_allowance >= 0);
size_t *num_processed)
{
BIO *next = BIO_next(b);
- ossl_ssize_t ret = 0;
+ int ret = 0;
size_t i = 0, tmpnump;
QUIC_PKT_HDR hdr;
PACKET pkt;
static int tls_dump_puts(BIO *bio, const char *str)
{
- return tls_dump_write(bio, str, strlen(str));
+ return tls_dump_write(bio, str, (int)strlen(str));
}
*/
if (duprec && i != 2) {
memcpy(thispkt->data, in + len, inl - len);
- thispkt->len = inl - len;
+ thispkt->len = inl - (int)len;
} else {
memcpy(thispkt->data, in, inl);
thispkt->len = inl;
static int mempacket_test_puts(BIO *bio, const char *str)
{
- return mempacket_test_write(bio, str, strlen(str));
+ return mempacket_test_write(bio, str, (int)strlen(str));
}
static int always_retry_new(BIO *bi);
*/
for (i = 0; i < 2; i++) {
if (SSL_read_ex(clientssl, &buf, sizeof(buf), &readbytes) > 0) {
- if (!TEST_ulong_eq(readbytes, 0))
+ if (!TEST_size_t_eq(readbytes, 0))
return 0;
} else if (!TEST_int_eq(SSL_get_error(clientssl, 0),
SSL_ERROR_WANT_READ)) {
hdr = strchr(hdr, ' ');
if (hdr == NULL)
return 0;
- len = strlen("HTTP/1.");
+ len = (int)strlen("HTTP/1.");
if (!TEST_strn_eq(++hdr, "HTTP/1.", len))
return 0;
hdr += len;
if (!TEST_char_eq(*hdr++, '\r') || !TEST_char_eq(*hdr++, '\n'))
return 0;
- count -= (hdr - req);
+ count -= (long)(hdr - req);
if (count < 0 || out == NULL)
return 0;
if (is_get) { /* construct new header and body */
if (txt != NULL)
- len = strlen(txt);
+ len = (int)strlen(txt);
else if ((len = ASN1_item_i2d(rsp, NULL, it)) <= 0)
return 0;
if (BIO_printf(out, "Content-Type: %s\r\n"
{
IDEA_KEY_SCHEDULE key, dkey;
unsigned char iv[IDEA_BLOCK];
- const size_t text_len = sizeof(text);
+ const long text_len = sizeof(text);
IDEA_set_encrypt_key(k, &key);
IDEA_set_decrypt_key(&key, &dkey);
unsigned char iv[AES_BLOCK_SIZE * 2];
int testresult = 1;
- if (!TEST_int_le(v->length, MAX_VECTOR_SIZE))
+ if (!TEST_size_t_le(v->length, MAX_VECTOR_SIZE))
return 0;
if (v->encrypt == AES_ENCRYPT)
AES_KEY key2;
unsigned char buf[MAX_VECTOR_SIZE];
- if (!TEST_int_le(v->length, MAX_VECTOR_SIZE))
+ if (!TEST_size_t_le(v->length, MAX_VECTOR_SIZE))
return 0;
if (v->encrypt == AES_ENCRYPT) {
- AES_set_encrypt_key(v->key1, 8 * v->keysize, &key1);
- AES_set_encrypt_key(v->key2, 8 * v->keysize, &key2);
+ AES_set_encrypt_key(v->key1, (int)(8 * v->keysize), &key1);
+ AES_set_encrypt_key(v->key2, (int)(8 * v->keysize), &key2);
} else {
- AES_set_decrypt_key(v->key1, 8 * v->keysize, &key1);
- AES_set_decrypt_key(v->key2, 8 * v->keysize, &key2);
+ AES_set_decrypt_key(v->key1, (int)(8 * v->keysize), &key1);
+ AES_set_decrypt_key(v->key2, (int)(8 * v->keysize), &key2);
}
AES_bi_ige_encrypt(v->in, buf, v->length, &key1, &key2, v->iv,
*/
for (i = 0; i < OSSL_NELEM(expected); i++) {
- int rv = TEST_int_eq(expected[i], keydata[i]);
+ int rv = TEST_uint64_t_eq((uint64_t)expected[i], (uint64_t)keydata[i]);
if (!rv)
TEST_info("i = %zu", i);
}
/* num_items */
- if (!TEST_int_eq((size_t)lh_int_num_items(h), n_int_tests))
+ if (!TEST_size_t_eq((size_t)lh_int_num_items(h), n_int_tests))
goto end;
/* retrieve */
}
/* num_items */
- if (!TEST_int_eq((size_t)ossl_ht_count(ht), n_int_tests))
+ if (!TEST_size_t_eq(ossl_ht_count(ht), n_int_tests))
goto end;
/* foreach, no arg */
/* filter */
list = ossl_ht_filter(ht, 64, int_filter_all, NULL);
- if (!TEST_int_eq((size_t)list->list_len, n_int_tests))
+ if (!TEST_size_t_eq(list->list_len, n_int_tests))
goto end;
ossl_ht_value_list_free(list);
}
/* make sure we stored everything */
- if (!TEST_int_eq((size_t)ossl_ht_count(h), n))
+ if (!TEST_size_t_eq(ossl_ht_count(h), n))
goto end;
/* delete or get in a different order */
INTL *c, *d;
OSSL_LIST(int) l;
INTL elem[20];
- size_t i;
+ int i;
int n = 1;
ossl_list_int_init(&l);
- for (i = 0; i < OSSL_NELEM(elem); i++) {
+ for (i = 0; i < (int)OSSL_NELEM(elem); i++) {
ossl_list_int_init_elem(elem + i);
elem[i].n = i;
}
td->msg, td->msg_len), 1)
|| !TEST_true(EVP_PKEY_get_size_t_param(pkey, OSSL_PKEY_PARAM_MAX_SIZE,
&sig_len2))
- || !TEST_int_eq(sig_len2, psig_len)
+ || !TEST_size_t_eq(sig_len2, psig_len)
|| !TEST_ptr(psig = OPENSSL_zalloc(psig_len))
|| !TEST_int_eq(EVP_PKEY_sign(sctx, psig, &psig_len,
td->msg, td->msg_len), 1)
|| !TEST_int_eq(EVP_PKEY_sign_message_final(sctx, NULL, &psig_len), 1)
|| !TEST_true(EVP_PKEY_get_size_t_param(pkey, OSSL_PKEY_PARAM_MAX_SIZE,
&sig_len2))
- || !TEST_int_eq(sig_len2, psig_len)
+ || !TEST_size_t_eq(sig_len2, psig_len)
|| !TEST_ptr(psig = OPENSSL_zalloc(psig_len))
|| !TEST_int_eq(EVP_PKEY_sign_message_final(sctx, psig, &psig_len), 1)
|| !TEST_int_eq(EVP_Q_digest(lib_ctx, "SHA256", NULL, psig, psig_len,
|| !TEST_int_eq(EVP_PKEY_eq(pkey, pkey2), 0)
|| !TEST_int_eq(EVP_PKEY_eq(pkey, pkey3), -1)
|| !TEST_int_eq(EVP_PKEY_get_raw_private_key(pkey, NULL, &len), 1)
- || !TEST_int_gt(len, 0)
+ || !TEST_size_t_gt(len, 0)
|| !TEST_ptr(priv = OPENSSL_malloc(len))
|| !TEST_int_eq(EVP_PKEY_get_raw_private_key(pkey, priv, &len), 1)
|| !TEST_int_eq(EVP_PKEY_get_raw_public_key(pkey, NULL, &len), 1)
- || !TEST_int_gt(len, 0)
+ || !TEST_size_t_gt(len, 0)
|| !TEST_ptr(pub = OPENSSL_malloc(len))
|| !TEST_int_eq(EVP_PKEY_get_raw_public_key(pkey, pub, &len), 1)
/* Load just the public part into a PKEY */
if (C.size == 1)
C.data = NULL;
- AES_set_encrypt_key(K.data, K.size * 8, &key);
+ AES_set_encrypt_key(K.data, (int)(K.size * 8), &key);
CRYPTO_gcm128_init(&ctx, &key, (block128_f)AES_encrypt);
CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);
} else if (strcmp(params->key, "p3") == 0) {
BN_free(obj->p3);
if (!TEST_ptr(obj->p3 = BN_native2bn(params->data,
- params->data_size, NULL)))
+ (int)params->data_size, NULL)))
return 0;
} else if (strcmp(params->key, "p4") == 0) {
OPENSSL_free(obj->p4);
params->return_size = BN_num_bytes(obj->p3);
if (!TEST_size_t_ge(params->data_size, params->return_size))
return 0;
- BN_bn2nativepad(obj->p3, params->data, params->return_size);
+ BN_bn2nativepad(obj->p3, params->data, (int)params->return_size);
} else if (strcmp(params->key, "p4") == 0) {
params->return_size = strlen(obj->p4);
if (!TEST_size_t_gt(params->data_size, params->return_size))
|| !TEST_int_eq(app_p1, p1_init) /* "provider" value */
|| !TEST_double_eq(app_p2, app_p2_init) /* Should remain untouched */
|| !TEST_ptr(p = OSSL_PARAM_locate(params, "p3"))
- || !TEST_ptr(BN_native2bn(bignumbin, p->return_size, app_p3))
+ || !TEST_ptr(BN_native2bn(bignumbin, (int)p->return_size, app_p3))
|| !TEST_BN_eq(app_p3, verify_p3) /* "provider" value */
|| !TEST_str_eq(app_p4, p4_init) /* "provider" value */
|| !TEST_ptr(p = OSSL_PARAM_locate(params, "p5"))
|| !TEST_int_eq(app_p1, app_p1_init) /* app value */
|| !TEST_double_eq(app_p2, app_p2_init) /* Should remain untouched */
|| !TEST_ptr(p = OSSL_PARAM_locate(params, "p3"))
- || !TEST_ptr(BN_native2bn(bignumbin, p->return_size, app_p3))
+ || !TEST_ptr(BN_native2bn(bignumbin, (int)p->return_size, app_p3))
|| !TEST_BN_eq(app_p3, verify_p3) /* app value */
|| !TEST_str_eq(app_p4, app_p4_init) /* app value */
|| !TEST_ptr(p = OSSL_PARAM_locate(params, "p5"))
if (!TEST_true(PKCS5_pbe_set0_algor(algor, EVP_CIPHER_nid(cipher), pbe_iter,
pbe_salt, sizeof(pbe_salt)))
- || !TEST_true(PKCS5_PBE_keyivgen(ctx, pbe_password, strlen(pbe_password),
+ || !TEST_true(PKCS5_PBE_keyivgen(ctx, pbe_password, (int)strlen(pbe_password),
algor->parameter, cipher, md, 1))
|| !TEST_true(EVP_CipherUpdate(ctx, out, &i, pbe_plaintext,
sizeof(pbe_plaintext))))
/* Decrypt */
- if (!TEST_true(PKCS5_PBE_keyivgen(ctx, pbe_password, strlen(pbe_password),
+ if (!TEST_true(PKCS5_PBE_keyivgen(ctx, pbe_password, (int)strlen(pbe_password),
algor->parameter, cipher, md, 0))
|| !TEST_true(EVP_CipherUpdate(ctx, out, &i, exp, exp_len)))
goto err;
PEM_FLAG_ONLY_B64)))
goto err;
if (!TEST_int_eq(memcmp(pemtype, name, strlen(pemtype)), 0)
- || !TEST_int_eq(len, strlen(raw))
+ || !TEST_long_eq(len, (long)strlen(raw))
|| !TEST_int_eq(memcmp(data, raw, strlen(raw)), 0))
goto err;
ret = 1;
long len;
int ret = 0;
- b = BIO_new_mem_buf(emptypay, strlen(emptypay));
+ b = BIO_new_mem_buf(emptypay, (int)strlen(emptypay));
if (!TEST_ptr(b))
return 0;
EVP_PKEY *pkey = NULL;
int ret = 0;
- b = BIO_new_mem_buf(protectedpay, strlen(protectedpay));
+ b = BIO_new_mem_buf(protectedpay, (int)strlen(protectedpay));
if (!TEST_ptr(b))
return 0;
for (i = 0; i < OSSL_NELEM(sig); ++i)
BIO_puts(bio, sig[i]);
- ret = TEST_ptr(msg_bio = BIO_new_mem_buf(signed_data, strlen(signed_data)))
+ ret = TEST_ptr(msg_bio = BIO_new_mem_buf(signed_data, (int)strlen(signed_data)))
&& TEST_ptr(x509_bio = BIO_new_mem_buf(cert_der, sizeof(cert_der)))
&& TEST_ptr(cert = d2i_X509_bio(x509_bio, NULL))
&& TEST_int_eq(ERR_peek_error(), 0)
OSSL_ACKM_TX_PKT *txs = NULL, *tx;
OSSL_TIME ack_deadline[QUIC_PN_SPACE_NUM];
size_t opn = 0;
+ int j;
for (i = 0; i < QUIC_PN_SPACE_NUM; ++i)
ack_deadline[i] = ossl_time_infinite();
s->expect_deadline))
goto err;
- for (i = 0; i < QUIC_PN_SPACE_NUM; ++i) {
- if (i != (size_t)space
- && !TEST_true(ossl_time_is_infinite(ossl_ackm_get_ack_deadline(h.ackm, i))))
+ for (j = 0; j < QUIC_PN_SPACE_NUM; ++j) {
+ if (j != space
+ && !TEST_true(ossl_time_is_infinite(ossl_ackm_get_ack_deadline(h.ackm, j))))
goto err;
- if (!TEST_int_eq(ossl_time_compare(ossl_ackm_get_ack_deadline(h.ackm, i),
- ack_deadline[i]), 0))
+ if (!TEST_int_eq(ossl_time_compare(ossl_ackm_get_ack_deadline(h.ackm, j),
+ ack_deadline[j]), 0))
goto err;
}
/* 0 is the success case for SSL_set_alpn_protos(). */
if (!TEST_false(SSL_set_alpn_protos(h->c_conn, tmp_buf,
- alpn_len + 1)))
+ (unsigned int)(alpn_len + 1))))
goto out;
OPENSSL_free(tmp_buf);
if (!TEST_ptr(c_tgt))
goto out;
- if (!TEST_true(SSL_set_default_stream_mode(c_tgt, op->arg1)))
+ if (!TEST_true(SSL_set_default_stream_mode(c_tgt, (uint32_t)op->arg1)))
goto out;
}
break;
goto out;
if (!TEST_true(SSL_set_incoming_stream_policy(c_tgt,
- op->arg1, 0)))
+ (int)op->arg1, 0)))
goto out;
}
break;
h->threads[i].h = h;
h->threads[i].script = op->arg0;
h->threads[i].script_name = script_name;
- h->threads[i].thread_idx = i;
+ h->threads[i].thread_idx = (int)i;
h->threads[i].m = ossl_crypto_mutex_new();
if (!TEST_ptr(h->threads[i].m))
QUIC_CHANNEL *ch = ossl_quic_conn_get_channel(h->c_conn);
ossl_quic_engine_set_inhibit_tick(ossl_quic_channel_get0_engine(ch),
- op->arg1);
+ (int)op->arg1);
}
break;
{
uint64_t v = 0;
- if (!TEST_true(SSL_get_value_uint(h->c_conn, hl->check_op->arg1,
+ if (!TEST_true(SSL_get_value_uint(h->c_conn, (uint32_t)hl->check_op->arg1,
SSL_VALUE_QUIC_IDLE_TIMEOUT,
&v)))
return 0;
if (!TEST_true(qtest_create_quic_connection(qtserv, cssl)))
goto err;
- if (!TEST_int_eq(SSL_write(cssl, msg, msglen), msglen))
+ if (!TEST_int_eq(SSL_write(cssl, msg, (int)msglen), (int)msglen))
goto err;
ossl_quic_tserver_tick(qtserv);
if (!TEST_true(SSL_handle_events(cssl)))
goto err;
- if (!TEST_int_eq(SSL_read(cssl, buf, sizeof(buf)), msglen))
+ if (!TEST_int_eq(SSL_read(cssl, buf, sizeof(buf)), (int)msglen))
goto err;
if (!TEST_mem_eq(msg, msglen, buf, bytesread))
goto err;
- if (!TEST_int_eq(SSL_write(cssl, msg, msglen), msglen))
+ if (!TEST_int_eq(SSL_write(cssl, msg, (int)msglen), (int)msglen))
goto err;
ossl_quic_tserver_tick(qtserv);
{
ADD_ALL_TESTS(test_script, OSSL_NELEM(scripts));
ADD_ALL_TESTS(test_dyn_script_1,
- OSSL_NELEM(dyn_script_1_crypto_1a)
- - dyn_script_1_start_from + 1);
+ (int)(OSSL_NELEM(dyn_script_1_crypto_1a)
+ - dyn_script_1_start_from + 1));
return 1;
}
/* No failure modes for padding */
return 1;
- if (!TEST_int_eq(ossl_quic_wire_decode_padding(pkt), 3))
+ if (!TEST_size_t_eq(ossl_quic_wire_decode_padding(pkt), 3))
return 0;
return 1;
if (!TEST_true(SSL_read_ex(clientquic, buf, 1, &numbytes))
|| !TEST_size_t_eq(numbytes, 1)
|| !TEST_true(SSL_has_pending(clientquic))
- || !TEST_int_eq(SSL_pending(clientquic), msglen - 1)
+ || !TEST_int_eq(SSL_pending(clientquic), (int)(msglen - 1))
|| !TEST_true(SSL_read_ex(clientquic, buf + 1,
sizeof(buf) - 1, &numbytes))
|| !TEST_mem_eq(buf, numbytes + 1, msg, msglen))
#endif
TLS1_3_CK_AES_128_GCM_SHA256
};
- size_t i, j;
+ size_t i;
+ int j;
if (!TEST_ptr(ctx))
return 0;
static int ensure_valid_ciphers(const STACK_OF(SSL_CIPHER) *ciphers)
{
- size_t i;
+ int i;
/* Ensure ciphersuite list is suitably subsetted. */
- for (i = 0; i < (size_t)sk_SSL_CIPHER_num(ciphers); ++i) {
+ for (i = 0; i < sk_SSL_CIPHER_num(ciphers); ++i) {
const SSL_CIPHER *cipher = sk_SSL_CIPHER_value(ciphers, i);
+
switch (SSL_CIPHER_get_id(cipher)) {
case TLS1_3_CK_AES_128_GCM_SHA256:
case TLS1_3_CK_AES_256_GCM_SHA384:
if (!TEST_true(qtest_create_quic_connection(qtserv, cssl)))
goto err;
- if (!TEST_int_eq(SSL_write(cssl, msg, msglen), msglen))
+ if (!TEST_int_eq(SSL_write(cssl, msg, (int)msglen), (int)msglen))
goto err;
ossl_quic_tserver_tick(qtserv);
static void RADIX_PROCESS_report_thread_results(RADIX_PROCESS *rp, BIO *bio)
{
- size_t i;
+ int i;
RADIX_THREAD *rt;
char *p;
long l;
char pfx_buf[64];
int rt_testresult;
- for (i = 1; i < (size_t)sk_RADIX_THREAD_num(rp->threads); ++i) {
+ for (i = 1; i < sk_RADIX_THREAD_num(rp->threads); ++i) {
rt = sk_RADIX_THREAD_value(rp->threads, i);
ossl_crypto_mutex_lock(rt->m);
static int RADIX_PROCESS_join_all_threads(RADIX_PROCESS *rp, int *testresult)
{
int ok = 1;
- size_t i;
+ int i;
RADIX_THREAD *rt;
int composite_testresult = 1;
return 1;
}
- for (i = 1; i < (size_t)sk_RADIX_THREAD_num(rp->threads); ++i) {
+ for (i = 1; i < sk_RADIX_THREAD_num(rp->threads); ++i) {
rt = sk_RADIX_THREAD_value(rp->threads, i);
- BIO_printf(bio_err, "==> Joining thread %zu\n", i);
+ BIO_printf(bio_err, "==> Joining thread %d\n", i);
if (!TEST_true(RADIX_THREAD_join(rt)))
ok = 0;
static void RADIX_PROCESS_cleanup(RADIX_PROCESS *rp)
{
- size_t i;
+ int i;
assert(rp->done_join_all_threads);
- for (i = 0; i < (size_t)sk_RADIX_THREAD_num(rp->threads); ++i)
+ for (i = 0; i < sk_RADIX_THREAD_num(rp->threads); ++i)
RADIX_THREAD_free(sk_RADIX_THREAD_value(rp->threads, i));
sk_RADIX_THREAD_free(rp->threads);
buf = OPENSSL_malloc(thislen);
if (!TEST_ptr(buf))
goto err;
- if (!TEST_int_eq(RAND_bytes(buf, thislen), 1))
+ if (!TEST_int_eq(RAND_bytes(buf, (int)thislen), 1))
goto err;
r = SSL_write_ex(ssl, buf, thislen, &bytes_written);
if (!TEST_true(r)
goto end;
if (type == TLSEXT_TYPE_server_name) {
if (!TEST_true(PACKET_get_length_prefixed_2(&pkt3, &pkt4))
- || !TEST_uint_ne(PACKET_remaining(&pkt4), 0)
+ || !TEST_size_t_ne(PACKET_remaining(&pkt4), 0)
|| !TEST_true(PACKET_get_1(&pkt4, &servname_type))
|| !TEST_uint_eq(servname_type, TLSEXT_NAMETYPE_host_name)
|| !TEST_true(PACKET_get_length_prefixed_2(&pkt4, &pkt5))
- || !TEST_uint_le(PACKET_remaining(&pkt5), TLSEXT_MAXLEN_host_name)
+ || !TEST_size_t_le(PACKET_remaining(&pkt5), TLSEXT_MAXLEN_host_name)
|| !TEST_false(PACKET_contains_zero_byte(&pkt5))
|| !TEST_true(PACKET_strndup(&pkt5, sni)))
goto end;
return 0;
}
- if (!TEST_int_le(inlen, sizeof(in)))
+ if (!TEST_size_t_le(inlen, sizeof(in)))
return 0;
/* key and in data are 00 01 02 ... */
td->msg, td->msg_len), 1)
|| !TEST_true(EVP_PKEY_get_size_t_param(pkey, OSSL_PKEY_PARAM_MAX_SIZE,
&sig_len2))
- || !TEST_int_eq(sig_len2, psig_len)
+ || !TEST_size_t_eq(sig_len2, psig_len)
|| !TEST_ptr(psig = OPENSSL_zalloc(psig_len))
|| !TEST_int_eq(EVP_PKEY_sign(sctx, psig, &psig_len,
td->msg, td->msg_len), 1))
pub, sizeof(pub), &pub_len)))
goto err;
if (!TEST_true(EVP_PKEY_get_int_param(pkey, OSSL_PKEY_PARAM_BITS, &bits))
- || !TEST_int_eq(bits, 8 * 2 * n)
+ || !TEST_size_t_eq((size_t)bits, 8 * 2 * n)
|| !TEST_true(EVP_PKEY_get_int_param(pkey, OSSL_PKEY_PARAM_SECURITY_BITS,
&sec_bits))
- || !TEST_int_eq(sec_bits, 8 * n)
+ || !TEST_size_t_eq((size_t)sec_bits, 8 * n)
|| !TEST_true(EVP_PKEY_get_int_param(pkey, OSSL_PKEY_PARAM_MAX_SIZE,
&sig_len))
|| !TEST_int_ge(sig_len, 7856)
goto done;
if (!TEST_true(ossl_sm2_plaintext_size(ctext, ctext_len, &ptext_len))
- || !TEST_int_eq(ptext_len, msg_len))
+ || !TEST_size_t_eq(ptext_len, msg_len))
goto done;
recovered = OPENSSL_zalloc(ptext_len);
if (!TEST_ptr(recovered)
|| !TEST_true(ossl_sm2_decrypt(key, digest, ctext, ctext_len,
recovered, &recovered_len))
- || !TEST_int_eq(recovered_len, msg_len)
|| !TEST_mem_eq(recovered, recovered_len, message, msg_len))
goto done;
abort();
}
- if (SSL_select_next_proto
- ((unsigned char **)out, outlen, protos, protos_len, in,
- inlen) != OPENSSL_NPN_NEGOTIATED) {
+ if (SSL_select_next_proto((unsigned char **)out, outlen, protos,
+ (unsigned int)protos_len,
+ in, inlen) != OPENSSL_NPN_NEGOTIATED) {
OPENSSL_free(protos);
return SSL_TLSEXT_ERR_NOACK;
}
bytes = atol(*(++argv));
if (bytes == 0L)
bytes = 1L;
- i = strlen(argv[0]);
+ i = (int)strlen(argv[0]);
if (argv[0][i - 1] == 'k')
bytes *= 1024L;
if (argv[0][i - 1] == 'm')
goto end;
}
/* Returns 0 on success!! */
- if (SSL_CTX_set_alpn_protos(c_ctx, alpn, alpn_len)) {
+ if (SSL_CTX_set_alpn_protos(c_ctx, alpn, (unsigned int)alpn_len)) {
BIO_printf(bio_err, "Error setting ALPN\n");
OPENSSL_free(alpn);
goto end;
static void client_keylog_callback(const SSL *ssl, const char *line)
{
- int line_length = strlen(line);
+ int line_length = (int)strlen(line);
/* If the log doesn't fit, error out. */
if (client_log_buffer_index + line_length > sizeof(client_log_buffer) - 1) {
static void server_keylog_callback(const SSL *ssl, const char *line)
{
- int line_length = strlen(line);
+ int line_length = (int)strlen(line);
/* If the log doesn't fit, error out. */
if (server_log_buffer_index + line_length > sizeof(server_log_buffer) - 1) {
|| !TEST_true(create_ssl_connection(serverssl, clientssl,
SSL_ERROR_NONE))
|| !TEST_false(error_writing_log)
- || !TEST_int_gt(client_log_buffer_index, 0)
- || !TEST_int_gt(server_log_buffer_index, 0))
+ || !TEST_size_t_gt(client_log_buffer_index, 0)
+ || !TEST_size_t_gt(server_log_buffer_index, 0))
goto end;
/*
/* Actually drive the renegotiation. */
for (i = 0; i < 3; i++) {
if (SSL_read_ex(clientssl, &buf, sizeof(buf), &readbytes) > 0) {
- if (!TEST_ulong_eq(readbytes, 0))
+ if (!TEST_size_t_eq(readbytes, 0))
goto end;
} else if (!TEST_int_eq(SSL_get_error(clientssl, 0),
SSL_ERROR_WANT_READ)) {
goto end;
}
if (SSL_read_ex(serverssl, &buf, sizeof(buf), &readbytes) > 0) {
- if (!TEST_ulong_eq(readbytes, 0))
+ if (!TEST_size_t_eq(readbytes, 0))
goto end;
} else if (!TEST_int_eq(SSL_get_error(serverssl, 0),
SSL_ERROR_WANT_READ)) {
rr = serversc->rlayer.tlsrecs;
zbuf = &rr->data[rr->off];
- if (!TEST_int_eq(rr->length, sizeof(cbuf)))
+ if (!TEST_size_t_eq(rr->length, sizeof(cbuf)))
goto end;
/*
|| !TEST_int_eq(idx * 2 + 2, new_called)
|| !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes))
|| !TEST_int_eq(idx * 2 + 4, new_called)
- || !TEST_int_eq(sizeof(buf), nbytes)
+ || !TEST_size_t_eq(sizeof(buf), nbytes)
|| !TEST_int_eq(c, buf[0])
|| !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes)))
goto end;
|| !TEST_int_eq(0, new_called)
|| !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes))
|| !TEST_int_eq(0, new_called)
- || !TEST_int_eq(sizeof(buf), nbytes)
+ || !TEST_size_t_eq(sizeof(buf), nbytes)
|| !TEST_int_eq(c, buf[0])
|| !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes)))
goto end;
|| !TEST_int_eq(2, new_called)
|| !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes))
|| !TEST_int_eq(4, new_called)
- || !TEST_int_eq(sizeof(buf), nbytes)
+ || !TEST_size_t_eq(sizeof(buf), nbytes)
|| !TEST_int_eq(c, buf[0])
|| !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes)))
goto end;
int ret;
if (curr->list != NULL)
- ret = SSL_CTX_set1_sigalgs(cctx, curr->list, curr->listlen);
+ ret = SSL_CTX_set1_sigalgs(cctx, curr->list, (long)curr->listlen);
else
ret = SSL_CTX_set1_sigalgs_list(cctx, curr->liststr);
int ret;
if (curr->list != NULL)
- ret = SSL_set1_sigalgs(clientssl, curr->list, curr->listlen);
+ ret = SSL_set1_sigalgs(clientssl, curr->list, (long)curr->listlen);
else
ret = SSL_set1_sigalgs_list(clientssl, curr->liststr);
if (!ret) {
unsigned char *psk,
unsigned int max_psk_len)
{
- unsigned int psklen = 0;
+ size_t psklen = 0;
psk_client_cb_cnt++;
psklen = SSL_SESSION_get_master_key(clientpsk, psk, max_psk_len);
strncpy(id, pskid, max_id_len);
- return psklen;
+ return (unsigned int)psklen;
}
#endif /* OPENSSL_NO_PSK */
static unsigned int psk_server_cb(SSL *ssl, const char *identity,
unsigned char *psk, unsigned int max_psk_len)
{
- unsigned int psklen = 0;
+ size_t psklen = 0;
psk_server_cb_cnt++;
return 0;
psklen = SSL_SESSION_get_master_key(serverpsk, psk, max_psk_len);
- return psklen;
+ return (unsigned int)psklen;
}
#endif /* OPENSSL_NO_PSK */
static int verify_stateless_cookie_callback(SSL *ssl, const unsigned char *cookie,
size_t cookie_len)
{
- return verify_cookie_callback(ssl, cookie, cookie_len);
+ return verify_cookie_callback(ssl, cookie, (unsigned int)cookie_len);
}
static int test_stateless(void)
}
/* Check that sending and receiving app data is ok */
- if (!TEST_int_eq(SSL_write(clientssl, mess, strlen(mess)), strlen(mess))
+ if (!TEST_int_eq(SSL_write(clientssl, mess, (int)strlen(mess)), (int)strlen(mess))
|| !TEST_int_eq(SSL_read(serverssl, buf, sizeof(buf)),
- strlen(mess)))
+ (int)strlen(mess)))
goto end;
- if (!TEST_int_eq(SSL_write(serverssl, mess, strlen(mess)), strlen(mess))
+ if (!TEST_int_eq(SSL_write(serverssl, mess, (int)strlen(mess)), (int)strlen(mess))
|| !TEST_int_eq(SSL_read(clientssl, buf, sizeof(buf)),
- strlen(mess)))
+ (int)strlen(mess)))
goto end;
}
bretry = NULL;
/* Write data that we know will fail with SSL_ERROR_WANT_WRITE */
- if (!TEST_int_eq(SSL_write(peerwrite, mess, strlen(mess)), -1)
+ if (!TEST_int_eq(SSL_write(peerwrite, mess, (int)strlen(mess)), -1)
|| !TEST_int_eq(SSL_get_error(peerwrite, 0), SSL_ERROR_WANT_WRITE)
|| !TEST_true(SSL_want_write(peerwrite))
|| !TEST_true(SSL_net_write_desired(peerwrite)))
* Complete the write we started previously and read it from the other
* endpoint
*/
- if (!TEST_int_eq(SSL_write(peerwrite, mess, strlen(mess)), strlen(mess))
- || !TEST_int_eq(SSL_read(peerupdate, buf, sizeof(buf)), strlen(mess)))
+ if (!TEST_int_eq(SSL_write(peerwrite, mess, (int)strlen(mess)), (int)strlen(mess))
+ || !TEST_int_eq(SSL_read(peerupdate, buf, sizeof(buf)), (int)strlen(mess)))
goto end;
/* Write more data to ensure we send the KeyUpdate message back */
- if (!TEST_int_eq(SSL_write(peerwrite, mess, strlen(mess)), strlen(mess))
- || !TEST_int_eq(SSL_read(peerupdate, buf, sizeof(buf)), strlen(mess)))
+ if (!TEST_int_eq(SSL_write(peerwrite, mess, (int)strlen(mess)), (int)strlen(mess))
+ || !TEST_int_eq(SSL_read(peerupdate, buf, sizeof(buf)), (int)strlen(mess)))
goto end;
if (!TEST_false(SSL_net_read_desired(peerwrite))
goto end;
/* Now write some data in peer - we will write the key update */
- if (!TEST_int_eq(SSL_write(peer, mess, strlen(mess)), strlen(mess)))
+ if (!TEST_int_eq(SSL_write(peer, mess, (int)strlen(mess)), (int)strlen(mess)))
goto end;
/*
goto end;
/* check that sending and receiving appdata ok */
- if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), strlen(mess))
- || !TEST_int_eq(SSL_read(peer, prbuf, sizeof(prbuf)), strlen(mess)))
+ if (!TEST_int_eq(SSL_write(local, mess, (int)strlen(mess)), (int)strlen(mess))
+ || !TEST_int_eq(SSL_read(peer, prbuf, sizeof(prbuf)), (int)strlen(mess)))
goto end;
testresult = 1;
bretry = NULL;
/* write data in local will fail with SSL_ERROR_WANT_WRITE */
- if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), -1)
+ if (!TEST_int_eq(SSL_write(local, mess, (int)strlen(mess)), -1)
|| !TEST_int_eq(SSL_get_error(local, -1), SSL_ERROR_WANT_WRITE))
goto end;
ERR_clear_error();
/* write data in local previously that we will complete */
- if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), strlen(mess)))
+ if (!TEST_int_eq(SSL_write(local, mess, (int)strlen(mess)), (int)strlen(mess)))
goto end;
/* SSL_key_update will succeed because there is no pending write data */
* we write some appdata in local
* read data in peer - we will read the keyupdate msg
*/
- if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), strlen(mess))
- || !TEST_int_eq(SSL_read(peer, buf, sizeof(buf)), strlen(mess)))
+ if (!TEST_int_eq(SSL_write(local, mess, (int)strlen(mess)), (int)strlen(mess))
+ || !TEST_int_eq(SSL_read(peer, buf, sizeof(buf)), (int)strlen(mess)))
goto end;
/* Write more peer more data to ensure we send the keyupdate message back */
- if (!TEST_int_eq(SSL_write(peer, mess, strlen(mess)), strlen(mess))
- || !TEST_int_eq(SSL_read(local, buf, sizeof(buf)), strlen(mess)))
+ if (!TEST_int_eq(SSL_write(peer, mess, (int)strlen(mess)), (int)strlen(mess))
+ || !TEST_int_eq(SSL_read(local, buf, sizeof(buf)), (int)strlen(mess)))
goto end;
testresult = 1;
* write data in local
* read data in peer - we will read the key update
*/
- if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), strlen(mess))
- || !TEST_int_eq(SSL_read(peer, prbuf, sizeof(prbuf)), strlen(mess)))
+ if (!TEST_int_eq(SSL_write(local, mess, (int)strlen(mess)), (int)strlen(mess))
+ || !TEST_int_eq(SSL_read(peer, prbuf, sizeof(prbuf)), (int)strlen(mess)))
goto end;
/* Write more peer data to ensure we send the keyupdate message back */
- if (!TEST_int_eq(SSL_write(peer, mess, strlen(mess)), strlen(mess))
- || !TEST_int_eq(SSL_read(local, lrbuf, sizeof(lrbuf)), strlen(mess)))
+ if (!TEST_int_eq(SSL_write(peer, mess, (int)strlen(mess)), (int)strlen(mess))
+ || !TEST_int_eq(SSL_read(local, lrbuf, sizeof(lrbuf)), (int)strlen(mess)))
goto end;
testresult = 1;
goto end;
if (type == TLSEXT_TYPE_max_fragment_length) {
- if (!TEST_uint_ne(PACKET_remaining(&pkt3), 0)
+ if (!TEST_size_t_ne(PACKET_remaining(&pkt3), 0)
|| !TEST_true(PACKET_get_1(&pkt3, &MFL_code)))
goto end;
{
SSL_CTX *cctx = NULL, *sctx = NULL;
SSL *clientssl = NULL, *serverssl = NULL, *peera, *peerb;
- int testresult = 0, numreads;
+ int testresult = 0, numreads, numpipes = 5;
/* A 55 byte message */
unsigned char *msg = (unsigned char *)
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123";
- size_t written, readbytes, offset, msglen, fragsize = 10, numpipes = 5;
- size_t expectedreads;
+ size_t written, readbytes, offset, msglen, fragsize = 10;
+ int expectedreads;
unsigned char *buf = NULL;
ENGINE *e = NULL;
* Test that setting a split send fragment longer than the maximum
* allowed fails
*/
- if (!TEST_false(SSL_set_split_send_fragment(peera, fragsize + 1)))
+ if (!TEST_false(SSL_set_split_send_fragment(peera, (long)(fragsize + 1))))
goto end;
}
* but sufficient for our purposes
*/
if (!TEST_true(SSL_set_max_pipelines(peera, numpipes))
- || !TEST_true(SSL_set_split_send_fragment(peera, fragsize)))
+ || !TEST_true(SSL_set_split_send_fragment(peera, (long)fragsize)))
goto end;
if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
m2 += n2;
l1 -= n1;
l2 -= n2;
- cnt += width;
+ cnt += (unsigned int)width;
}
fin:
test_flush_stderr();
static int convert_bn_memory(const unsigned char *in, size_t bytes,
char *out, int *lz, const BIGNUM *bn)
{
- int n = bytes * 2, i;
+ int n = (int)(bytes * 2), i;
char *p = out, *q = NULL;
const char *r;
if (bn1 != NULL) {
m1 = bufp;
- BN_bn2binpad(bn1, m1, len);
+ BN_bn2binpad(bn1, m1, (int)len);
}
if (bn2 != NULL) {
m2 = bufp + len;
- BN_bn2binpad(bn2, m2, len);
+ BN_bn2binpad(bn2, m2, (int)len);
}
while (len > 0) {
- cnt = 8 * (len - bytes);
+ cnt = (unsigned int)(8 * (len - bytes));
n1 = convert_bn_memory(m1, bytes, b1, &lz1, bn1);
n2 = convert_bn_memory(m2, bytes, b2, &lz2, bn2);
m2 += n2;
l1 -= n1;
l2 -= n2;
- cnt += bytes;
+ cnt += (unsigned int)bytes;
}
fin:
test_flush_stderr();
BIO_set_prefix(trace_data->bio, buffer);
break;
case OSSL_TRACE_CTRL_WRITE:
- ret = BIO_write(trace_data->bio, buf, cnt);
+ if (cnt > INT_MAX)
+ cnt = INT_MAX;
+ ret = BIO_write(trace_data->bio, buf, (int)cnt);
break;
case OSSL_TRACE_CTRL_END:
trace_data->ingroup = 0;
uint32_t retval[3];
uint32_t local[3] = { 0 };
uint32_t threads_supported;
- size_t i;
+ uint32_t i;
void *t[3];
int status = 0;
OSSL_LIB_CTX *cust_ctx = OSSL_LIB_CTX_new();
if (!TEST_int_eq(ossl_crypto_thread_join(t[i], &retval[0]), 1))
goto cleanup;
- if (!TEST_int_eq(retval[0], i + 1) || !TEST_int_eq(local[0], i + 2))
+ if (!TEST_uint_eq(retval[0], i + 1) || !TEST_uint_eq(local[0], i + 2))
goto cleanup;
if (!TEST_int_eq(ossl_crypto_thread_clean(t[i]), 1))
goto cleanup;
}
for (i = 0; i < OSSL_NELEM(t); ++i) {
- if (!TEST_int_eq(retval[i], i + 1) || !TEST_int_eq(local[i], i + 2))
+ if (!TEST_uint_eq(retval[i], i + 1) || !TEST_uint_eq(local[i], i + 2))
goto cleanup;
if (!TEST_int_eq(ossl_crypto_thread_clean(t[i]), 1))
goto cleanup;
goto cleanup;
}
for (i = 0; i < OSSL_NELEM(t); ++i) {
- if (!TEST_int_eq(retval[i], i + 1) || !TEST_int_eq(local[i], i + 2))
+ if (!TEST_uint_eq(retval[i], i + 1) || !TEST_uint_eq(local[i], i + 2))
goto cleanup;
if (!TEST_int_eq(ossl_crypto_thread_clean(t[i]), 1))
goto cleanup;
if (!TEST_true(EVP_EncryptInit_ex(cipherctx, ciph, NULL, key, iv))
|| !TEST_true(EVP_EncryptUpdate(cipherctx, out, &ciphoutl,
(unsigned char *)message,
- messlen))
+ (int)messlen))
|| !TEST_true(EVP_EncryptFinal(cipherctx, out, &ciphoutl)))
goto err;
}
goto err;
}
- pem = BIO_new_mem_buf(pemdata, len);
+ pem = BIO_new_mem_buf(pemdata, (int)len);
if (pem == NULL) {
multi_set_success(0);
goto err;
int day, sec;
at.data = (unsigned char*)testdata->data;
- at.length = strlen(testdata->data);
+ at.length = (int)strlen(testdata->data);
at.type = testdata->type;
at.flags = 0;
return NULL;
}
/* First argument == -1 means "standard" */
- p8 = PKCS8_encrypt_ex(-1, ctx->cipher, kstr, klen, NULL, 0, 0, p8info, libctx, NULL);
+ p8 = PKCS8_encrypt_ex(-1, ctx->cipher, kstr, (int)klen, NULL, 0, 0, p8info,
+ libctx, NULL);
OPENSSL_cleanse(kstr, klen);
return p8;
}
static int watchccs_puts(BIO *bio, const char *str)
{
- return watchccs_write(bio, str, strlen(str));
+ return watchccs_write(bio, str, (int)strlen(str));
}
static int test_tls13ccs(int tst)
int res = 1;
OSSL_TRACE_BEGIN(HTTP) {
- res = TEST_int_eq(BIO_printf(trc_out, OSSL_HELLO), strlen(OSSL_HELLO));
- res += TEST_int_eq(trace_string(0, 0, OSSL_STR80), strlen(OSSL_STR80));
- res += TEST_int_eq(trace_string(0, 0, OSSL_STR81), strlen(OSSL_STR80));
- res += TEST_int_eq(trace_string(1, 1, OSSL_CTRL), strlen(OSSL_CTRL));
- res += TEST_int_eq(trace_string(0, 1, OSSL_MASKED), strlen(OSSL_MASKED)
+ res = TEST_int_eq(BIO_printf(trc_out, OSSL_HELLO), (int)strlen(OSSL_HELLO));
+ res += TEST_int_eq(trace_string(0, 0, OSSL_STR80), (int)strlen(OSSL_STR80));
+ res += TEST_int_eq(trace_string(0, 0, OSSL_STR81), (int)strlen(OSSL_STR80));
+ res += TEST_int_eq(trace_string(1, 1, OSSL_CTRL), (int)strlen(OSSL_CTRL));
+ res += TEST_int_eq(trace_string(0, 1, OSSL_MASKED), (int)strlen(OSSL_MASKED)
+ 1); /* newline added */
- res += TEST_int_eq(BIO_printf(trc_out, OSSL_BYE), strlen(OSSL_BYE));
+ res += TEST_int_eq(BIO_printf(trc_out, OSSL_BYE), (int)strlen(OSSL_BYE));
res = res == 6;
/* not using '&&' but '+' to catch potentially multiple test failures */
} OSSL_TRACE_END(HTTP);
static int test_pem_password_cb(char *buf, int size, int rwflag, void *userdata)
{
OPENSSL_strlcpy(buf, (char *)userdata, (size_t)size);
- return strlen(buf);
+ return (int)strlen(buf);
}
/*
for (i = 0; i < OSSL_NELEM(extvalues); i++) {
X509V3_CTX ctx;
BIO *extbio = BIO_new_mem_buf(extvalues[i].value,
- strlen(extvalues[i].value));
+ (int)strlen(extvalues[i].value));
CONF *conf;
long eline;
* We create two versions of each GENERAL_NAME so that we ensure when
* we compare them they are always different pointers.
*/
- namesa[i] = d2i_GENERAL_NAME(NULL, &derp, gennames[i].derlen);
+ namesa[i] = d2i_GENERAL_NAME(NULL, &derp, (long)gennames[i].derlen);
derp = gennames[i].der;
- namesb[i] = d2i_GENERAL_NAME(NULL, &derp, gennames[i].derlen);
+ namesb[i] = d2i_GENERAL_NAME(NULL, &derp, (long)gennames[i].derlen);
if (!TEST_ptr(namesa[i]) || !TEST_ptr(namesb[i]))
goto end;
}
p = test->data;
- ias = d2i_OSSL_IETF_ATTR_SYNTAX(NULL, &p, test->len);
+ ias = d2i_OSSL_IETF_ATTR_SYNTAX(NULL, &p, (long)test->len);
if ((test->valid && !TEST_ptr(ias))
|| (!test->valid && !TEST_ptr_null(ias)))
OPT_TEST_DECLARE_USAGE("[<attribute certs (PEM)>...]\n")
int setup_tests(void)
{
- int cnt;
+ size_t cnt;
if (!test_skip_common_options()) {
TEST_error("Error parsing test options\n");
return 0;
}
- ADD_ALL_TESTS(test_print_acert, cnt);
+ ADD_ALL_TESTS(test_print_acert, (int)cnt);
ADD_TEST(test_acert_sign);
ADD_ALL_TESTS(test_object_group_attr, OSSL_NELEM(ietf_syntax_tests));
}
n = test_get_argument_count();
- if (!TEST_int_gt(n, 0))
+ if (!TEST_size_t_gt(n, 0))
return 0;
- ADD_ALL_TESTS(test_509_dup_cert, n);
+ ADD_ALL_TESTS(test_509_dup_cert, (int)n);
return 1;
}
int setup_tests(void)
{
const unsigned char *p;
- int cnt;
+ size_t cnt;
cnt = test_get_argument_count();
if (cnt != 1) {
memset(&t, 0, sizeof(t));
t.type = x509_cmp_tests[idx].type;
t.data = (unsigned char*)(x509_cmp_tests[idx].data);
- t.length = strlen(x509_cmp_tests[idx].data);
+ t.length = (int)strlen(x509_cmp_tests[idx].data);
t.flags = 0;
result = X509_cmp_time(&t, &x509_cmp_tests[idx].cmp_time);
projects / thirdparty / openssl.git / commitdiff
