in_tag = (unsigned char *)t->tag;
return EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc)
- && (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, t->iv_len, NULL) > 0)
+ && (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, (int)t->iv_len, NULL) > 0)
&& (in_tag == NULL
- || EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, t->tag_len,
+ || EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, (int)t->tag_len,
in_tag) > 0)
&& EVP_CipherInit_ex(ctx, NULL, NULL, t->key, t->iv, enc)
&& EVP_CIPHER_CTX_set_padding(ctx, pad)
- && EVP_CipherUpdate(ctx, NULL, &tmp, t->aad, t->aad_len);
+ && EVP_CipherUpdate(ctx, NULL, &tmp, t->aad, (int)t->aad_len);
}
/* Test a single KAT for encrypt/decrypt */
if ((t->mode & CIPHER_MODE_ENCRYPT) != 0) {
if (!cipher_init(ctx, cipher, t, encrypt)
|| !EVP_CipherUpdate(ctx, ct_buf, &len, t->base.pt,
- t->base.pt_len)
+ (int)t->base.pt_len)
|| !EVP_CipherFinal_ex(ctx, ct_buf + len, &ct_len))
goto err;
if (t->tag != NULL) {
unsigned char tag[16] = { 0 };
- if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, t->tag_len,
+ if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, (int)t->tag_len,
tag) <= 0
|| memcmp(tag, t->tag, t->tag_len) != 0)
goto err;
if ((t->mode & CIPHER_MODE_DECRYPT) != 0) {
if (!(cipher_init(ctx, cipher, t, !encrypt)
&& EVP_CipherUpdate(ctx, pt_buf, &len,
- t->base.expected, t->base.expected_len)
+ t->base.expected, (int)t->base.expected_len)
&& EVP_CipherFinal_ex(ctx, pt_buf + len, &pt_len)))
goto err;
OSSL_SELF_TEST_oncorrupt_byte(st, pt_buf);
BIGNUM *bn = BN_CTX_get(ctx);
if (bn == NULL
- || (BN_bin2bn(p->data, p->data_len, bn) == NULL)
+ || (BN_bin2bn(p->data, (int)p->data_len, bn) == NULL)
|| !OSSL_PARAM_BLD_push_BN(bld, p->name, bn))
goto err;
break;
}
ret =
ossl_rsa_padding_add_PKCS1_OAEP_mgf1_ex(prsactx->libctx, tbuf,
- rsasize, in, inlen,
+ rsasize, in, (int)inlen,
prsactx->oaep_label,
- prsactx->oaep_labellen,
+ (int)prsactx->oaep_labellen,
prsactx->oaep_md,
prsactx->mgf1_md);
RSA_NO_PADDING);
OPENSSL_free(tbuf);
} else {
- ret = RSA_public_encrypt(inlen, in, out, prsactx->rsa,
+ ret = RSA_public_encrypt((int)inlen, in, out, prsactx->rsa,
prsactx->pad_mode);
}
/* A ret value of 0 is not an error */
if ((tbuf = OPENSSL_malloc(len)) == NULL)
return 0;
- ret = RSA_private_decrypt(inlen, in, tbuf, prsactx->rsa,
+ ret = RSA_private_decrypt((int)inlen, in, tbuf, prsactx->rsa,
RSA_NO_PADDING);
/*
* With no padding then, on success ret should be len, otherwise an
return 0;
}
}
- ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, outsize, tbuf,
- len, len,
+ ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, (int)outsize, tbuf,
+ (int)len, (int)len,
prsactx->oaep_label,
- prsactx->oaep_labellen,
+ (int)prsactx->oaep_labellen,
prsactx->oaep_md,
prsactx->mgf1_md);
} else {
pad_mode = RSA_PKCS1_NO_IMPLICIT_REJECT_PADDING;
else
pad_mode = prsactx->pad_mode;
- ret = RSA_private_decrypt(inlen, in, out, prsactx->rsa, pad_mode);
+ ret = RSA_private_decrypt((int)inlen, in, out, prsactx->rsa, pad_mode);
}
*outlen = constant_time_select_s(constant_time_msb_s(ret), *outlen, ret);
ret = constant_time_select_int(constant_time_msb(ret), 0, 1);
p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD);
if (p != NULL) {
- if (p->data_type != OSSL_PARAM_OCTET_STRING) {
+ if (p->data_type != OSSL_PARAM_OCTET_STRING || p->data_size > INT_MAX) {
ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
return 0;
}
- if (hw->set_tls1_aad(ctx, p->data, p->data_size) <= 0)
+ if (hw->set_tls1_aad(ctx, p->data, (int)p->data_size) <= 0)
return 0;
}
PROV_AES_HMAC_SHA1_CTX *sctx = (PROV_AES_HMAC_SHA1_CTX *)vctx;
if (ctx->base.enc)
- ret = aesni_set_encrypt_key(key, keylen * 8, &ctx->ks);
+ ret = aesni_set_encrypt_key(key, (int)(keylen * 8), &ctx->ks);
else
- ret = aesni_set_decrypt_key(key, keylen * 8, &ctx->ks);
+ ret = aesni_set_decrypt_key(key, (int)(keylen * 8), &ctx->ks);
SHA1_Init(&sctx->head); /* handy when benchmarking */
sctx->tail = sctx->head;
sha1_block_data_order(c, ptr, len / SHA_CBLOCK);
ptr += len;
- c->Nh += len >> 29;
- c->Nl += len <<= 3;
+ c->Nh += (unsigned int)(len >> 29);
+ c->Nl += (unsigned int)(len <<= 3);
if (c->Nl < (unsigned int)len)
c->Nh++;
}
blocks *= SHA_CBLOCK;
aes_off += blocks;
sha_off += blocks;
- sctx->md.Nh += blocks >> 29;
- sctx->md.Nl += blocks <<= 3;
+ sctx->md.Nh += (unsigned int)(blocks >> 29);
+ sctx->md.Nl += (unsigned int)(blocks <<= 3);
if (sctx->md.Nl < (unsigned int)blocks)
sctx->md.Nh++;
} else {
/* pad the payload|hmac */
plen += SHA_DIGEST_LENGTH;
- for (l = len - plen - 1; plen < len; plen++)
+ for (l = (unsigned int)(len - plen - 1); plen < len; plen++)
out[plen] = l;
/* encrypt HMAC|padding at once */
aesni_cbc_encrypt(out + aes_off, out + aes_off, len - aes_off,
/* figure out payload length */
pad = out[len - 1];
- maxpad = len - (SHA_DIGEST_LENGTH + 1);
+ maxpad = (unsigned int)(len - (SHA_DIGEST_LENGTH + 1));
maxpad |= (255 - maxpad) >> (sizeof(maxpad) * 8 - 8);
maxpad &= 255;
* we'll use the maxpad value instead of the supplied pad to make
* sure we perform well defined pointer arithmetic.
*/
- pad = constant_time_select(mask, pad, maxpad);
+ pad = constant_time_select((unsigned int)mask, pad, maxpad);
inp_len = len - (SHA_DIGEST_LENGTH + pad + 1);
- ctx->aux.tls_aad[plen - 2] = inp_len >> 8;
- ctx->aux.tls_aad[plen - 1] = inp_len;
+ ctx->aux.tls_aad[plen - 2] = (unsigned char)(inp_len >> 8);
+ ctx->aux.tls_aad[plen - 1] = (unsigned char)inp_len;
/* calculate HMAC */
sctx->md = sctx->head;
}
/* but pretend as if we hashed padded payload */
- bitlen = sctx->md.Nl + (inp_len << 3); /* at most 18 bits */
+ bitlen = sctx->md.Nl + (unsigned int)(inp_len << 3); /* at most 18 bits */
# ifdef BSWAP4
bitlen = BSWAP4(bitlen);
# else
if (inp_len >= 8192 && OPENSSL_ia32cap_P[2] & (1 << 5))
n4x = 2; /* AVX2 */
} else if ((n4x = param->interleave / 4) && n4x <= 2)
- inp_len = param->len;
+ inp_len = (unsigned int)param->len;
else
return -1;
PROV_AES_HMAC_SHA256_CTX *sctx = (PROV_AES_HMAC_SHA256_CTX *)vctx;
if (ctx->base.enc)
- ret = aesni_set_encrypt_key(key, ctx->base.keylen * 8, &ctx->ks);
+ ret = aesni_set_encrypt_key(key, (int)(ctx->base.keylen * 8), &ctx->ks);
else
- ret = aesni_set_decrypt_key(key, ctx->base.keylen * 8, &ctx->ks);
+ ret = aesni_set_decrypt_key(key, (int)(ctx->base.keylen * 8), &ctx->ks);
SHA256_Init(&sctx->head); /* handy when benchmarking */
sctx->tail = sctx->head;
sha256_block_data_order(c, ptr, len / SHA256_CBLOCK);
ptr += len;
- c->Nh += len >> 29;
- c->Nl += len <<= 3;
+ c->Nh += (unsigned int)(len >> 29);
+ c->Nl += (unsigned int)(len <<= 3);
if (c->Nl < (unsigned int)len)
c->Nh++;
}
blocks *= SHA256_CBLOCK;
aes_off += blocks;
sha_off += blocks;
- sctx->md.Nh += blocks >> 29;
- sctx->md.Nl += blocks <<= 3;
+ sctx->md.Nh += (unsigned int)(blocks >> 29);
+ sctx->md.Nl += (unsigned int)(blocks <<= 3);
if (sctx->md.Nl < (unsigned int)blocks)
sctx->md.Nh++;
} else {
/* pad the payload|hmac */
plen += SHA256_DIGEST_LENGTH;
- for (l = len - plen - 1; plen < len; plen++)
+ for (l = (unsigned int)(len - plen - 1); plen < len; plen++)
out[plen] = l;
/* encrypt HMAC|padding at once */
aesni_cbc_encrypt(out + aes_off, out + aes_off, len - aes_off,
/* figure out payload length */
pad = out[len - 1];
- maxpad = len - (SHA256_DIGEST_LENGTH + 1);
+ maxpad = (unsigned int)(len - (SHA256_DIGEST_LENGTH + 1));
maxpad |= (255 - maxpad) >> (sizeof(maxpad) * 8 - 8);
maxpad &= 255;
* we'll use the maxpad value instead of the supplied pad to make
* sure we perform well defined pointer arithmetic.
*/
- pad = constant_time_select(mask, pad, maxpad);
+ pad = constant_time_select((unsigned int)mask, pad, maxpad);
inp_len = len - (SHA256_DIGEST_LENGTH + pad + 1);
- ctx->aux.tls_aad[plen - 2] = inp_len >> 8;
- ctx->aux.tls_aad[plen - 1] = inp_len;
+ ctx->aux.tls_aad[plen - 2] = (unsigned char)(inp_len >> 8);
+ ctx->aux.tls_aad[plen - 1] = (unsigned char)(inp_len);
/* calculate HMAC */
sctx->md = sctx->head;
}
/* but pretend as if we hashed padded payload */
- bitlen = sctx->md.Nl + (inp_len << 3); /* at most 18 bits */
+ bitlen = sctx->md.Nl + (unsigned int)(inp_len << 3); /* at most 18 bits */
# ifdef BSWAP4
bitlen = BSWAP4(bitlen);
# else
if (inp_len >= 8192 && OPENSSL_ia32cap_P[2] & (1 << 5))
n4x = 2; /* AVX2 */
} else if ((n4x = param->interleave / 4) && n4x <= 2)
- inp_len = param->len;
+ inp_len = (unsigned int)param->len;
else
return -1;
#include "cipher_aes_ccm.h"
#define AES_HW_CCM_SET_KEY_FN(fn_set_enc_key, fn_blk, fn_ccm_enc, fn_ccm_dec) \
- fn_set_enc_key(key, keylen * 8, &actx->ccm.ks.ks); \
- CRYPTO_ccm128_init(&ctx->ccm_ctx, ctx->m, ctx->l, &actx->ccm.ks.ks, \
+ fn_set_enc_key(key, (int)(keylen * 8), &actx->ccm.ks.ks); \
+ CRYPTO_ccm128_init(&ctx->ccm_ctx, (unsigned int)ctx->m, \
+ (unsigned int)ctx->l, &actx->ccm.ks.ks, \
(block128_f)fn_blk); \
ctx->str = ctx->enc ? (ccm128_f)fn_ccm_enc : (ccm128_f)fn_ccm_dec; \
ctx->key_set = 1;
PROV_AES_GCM_CTX *actx = (PROV_AES_GCM_CTX *)ctx;
AES_KEY *ks = &actx->ks.ks;
- aesni_set_encrypt_key(key, keylen * 8, ks);
+ aesni_set_encrypt_key(key, (int)(keylen * 8), ks);
memset(gcmctx, 0, sizeof(*gcmctx));
gcmctx->key = ks;
ctx->key_set = 1;
/* Add remaining AAD to the hash (note, the hash is stored reflected) */
if (aad_len > 0) {
- ares = aad_len;
+ ares = (unsigned int)aad_len;
for (i = 0; i < aad_len; i++)
gcmctx->Xi.c[15 - i] ^= aad[i];
}
#endif
#ifdef BSAES_CAPABLE
if (BSAES_CAPABLE && dat->mode == EVP_CIPH_CBC_MODE) {
- ret = AES_set_decrypt_key(key, keylen * 8, ks);
+ ret = AES_set_decrypt_key(key, (int)(keylen * 8), ks);
dat->block = (block128_f)AES_decrypt;
dat->stream.cbc = (cbc128_f)ossl_bsaes_cbc_encrypt;
} else
#endif
#ifdef VPAES_CAPABLE
if (VPAES_CAPABLE) {
- ret = vpaes_set_decrypt_key(key, keylen * 8, ks);
+ ret = vpaes_set_decrypt_key(key, (int)(keylen * 8), ks);
dat->block = (block128_f)vpaes_decrypt;
dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
?(cbc128_f)vpaes_cbc_encrypt : NULL;
} else
#endif
{
- ret = AES_set_decrypt_key(key, keylen * 8, ks);
+ ret = AES_set_decrypt_key(key, (int)(keylen * 8), ks);
dat->block = (block128_f)AES_decrypt;
dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
? (cbc128_f)AES_cbc_encrypt : NULL;
#endif
#ifdef BSAES_CAPABLE
if (BSAES_CAPABLE && dat->mode == EVP_CIPH_CTR_MODE) {
- ret = AES_set_encrypt_key(key, keylen * 8, ks);
+ ret = AES_set_encrypt_key(key, (int)(keylen * 8), ks);
dat->block = (block128_f)AES_encrypt;
dat->stream.ctr = (ctr128_f)ossl_bsaes_ctr32_encrypt_blocks;
} else
#endif
#ifdef VPAES_CAPABLE
if (VPAES_CAPABLE) {
- ret = vpaes_set_encrypt_key(key, keylen * 8, ks);
+ ret = vpaes_set_encrypt_key(key, (int)(keylen * 8), ks);
dat->block = (block128_f)vpaes_encrypt;
dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
? (cbc128_f)vpaes_cbc_encrypt : NULL;
} else
#endif
{
- ret = AES_set_encrypt_key(key, keylen * 8, ks);
+ ret = AES_set_encrypt_key(key, (int)(keylen * 8), ks);
dat->block = (block128_f)AES_encrypt;
dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
? (cbc128_f)AES_cbc_encrypt : NULL;
if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
&& !dat->enc) {
- ret = aesni_set_decrypt_key(key, keylen * 8, ks);
+ ret = aesni_set_decrypt_key(key, (int)(keylen * 8), ks);
dat->block = (block128_f) aesni_decrypt;
dat->stream.cbc = dat->mode == EVP_CIPH_CBC_MODE ?
(cbc128_f) aesni_cbc_encrypt : NULL;
} else {
- ret = aesni_set_encrypt_key(key, keylen * 8, ks);
+ ret = aesni_set_encrypt_key(key, (int)(keylen * 8), ks);
dat->block = (block128_f) aesni_encrypt;
if (dat->mode == EVP_CIPH_CBC_MODE)
dat->stream.cbc = (cbc128_f) aesni_cbc_encrypt;
fn_block_enc, fn_block_dec, \
fn_stream_enc, fn_stream_dec) \
CRYPTO_ocb128_cleanup(&ctx->ocb); \
-fn_set_enc_key(key, keylen * 8, &ctx->ksenc.ks); \
-fn_set_dec_key(key, keylen * 8, &ctx->ksdec.ks); \
+fn_set_enc_key(key, (int)(keylen * 8), &ctx->ksenc.ks); \
+fn_set_dec_key(key, (int)(keylen * 8), &ctx->ksdec.ks); \
if (!CRYPTO_ocb128_init(&ctx->ocb, &ctx->ksenc.ks, &ctx->ksdec.ks, \
(block128_f)fn_block_enc, (block128_f)fn_block_dec, \
ctx->base.enc ? (ocb128_f)fn_stream_enc : \
* klen is the length of the underlying cipher, not the input key,
* which should be twice as long
*/
- return ossl_siv128_init(sctx, key, klen, ctx->cbc, ctx->ctr, libctx,
+ return ossl_siv128_init(sctx, key, (int)klen, ctx->cbc, ctx->ctr, libctx,
propq);
}
else
use_forward_transform = !ctx->enc;
if (use_forward_transform) {
- AES_set_encrypt_key(key, keylen * 8, &wctx->ks.ks);
+ AES_set_encrypt_key(key, (int)(keylen * 8), &wctx->ks.ks);
ctx->block = (block128_f)AES_encrypt;
} else {
- AES_set_decrypt_key(key, keylen * 8, &wctx->ks.ks);
+ AES_set_decrypt_key(key, (int)(keylen * 8), &wctx->ks.ks);
ctx->block = (block128_f)AES_decrypt;
}
}
return 0;
/* Input length must always be non-zero */
- if (inlen == 0) {
+ if (inlen == 0 || inlen > INT_MAX) {
ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_INPUT_LENGTH);
return -1;
}
if (pad)
inlen = (inlen + 7) / 8 * 8;
/* 8 byte prefix */
- return inlen + 8;
+ return (int)(inlen + 8);
} else {
/*
* If not padding output will be exactly 8 bytes smaller than
* input. If padding it will be at least 8 bytes smaller but we
* don't know how much.
*/
- return inlen - 8;
+ return (int)(inlen - 8);
}
}
size_t bits = bytes * 8; \
\
if (ctx->enc) { \
- fn_set_enc_key(key, bits, &xctx->ks1.ks); \
+ fn_set_enc_key(key, (int)bits, &xctx->ks1.ks); \
xctx->xts.block1 = (block128_f)fn_block_enc; \
} else { \
- fn_set_dec_key(key, bits, &xctx->ks1.ks); \
+ fn_set_dec_key(key, (int)bits, &xctx->ks1.ks); \
xctx->xts.block1 = (block128_f)fn_block_dec; \
} \
- fn_set_enc_key(key + bytes, bits, &xctx->ks2.ks); \
+ fn_set_enc_key(key + bytes, (int)bits, &xctx->ks2.ks); \
xctx->xts.block2 = (block128_f)fn_block_enc; \
xctx->xts.key1 = &xctx->ks1; \
xctx->xts.key2 = &xctx->ks2; \
{
PROV_ARIA_CCM_CTX *actx = (PROV_ARIA_CCM_CTX *)ctx;
- ossl_aria_set_encrypt_key(key, keylen * 8, &actx->ks.ks);
- CRYPTO_ccm128_init(&ctx->ccm_ctx, ctx->m, ctx->l, &actx->ks.ks,
+ ossl_aria_set_encrypt_key(key, (int)(keylen * 8), &actx->ks.ks);
+ CRYPTO_ccm128_init(&ctx->ccm_ctx, (unsigned int)ctx->m,
+ (unsigned int)ctx->l, &actx->ks.ks,
(block128_f)ossl_aria_encrypt);
ctx->str = NULL;
ctx->key_set = 1;
ARIA_KEY *ks = &adat->ks.ks;
if (dat->enc || (mode != EVP_CIPH_ECB_MODE && mode != EVP_CIPH_CBC_MODE))
- ret = ossl_aria_set_encrypt_key(key, keylen * 8, ks);
+ ret = ossl_aria_set_encrypt_key(key, (int)(keylen * 8), ks);
else
- ret = ossl_aria_set_decrypt_key(key, keylen * 8, ks);
+ ret = ossl_aria_set_decrypt_key(key, (int)(keylen * 8), ks);
if (ret < 0) {
ERR_raise(ERR_LIB_PROV, PROV_R_KEY_SETUP_FAILED);
return 0;
{
PROV_BLOWFISH_CTX *bctx = (PROV_BLOWFISH_CTX *)ctx;
- BF_set_key(&bctx->ks.ks, keylen, key);
+ BF_set_key(&bctx->ks.ks, (int)keylen, key);
return 1;
}
CAMELLIA_KEY *ks = &adat->ks.ks;
dat->ks = ks;
- ret = Camellia_set_key(key, keylen * 8, ks);
+ ret = Camellia_set_key(key, (int)(keylen * 8), ks);
if (ret < 0) {
ERR_raise(ERR_LIB_PROV, PROV_R_KEY_SETUP_FAILED);
return 0;
{
PROV_CAST_CTX *bctx = (PROV_CAST_CTX *)ctx;
- CAST_set_key(&(bctx->ks.ks), keylen, key);
+ CAST_set_key(&(bctx->ks.ks), (int)keylen, key);
return 1;
}
}
/* Is this the original IV or the running IV? */
- num = rc2_keybits_to_magic(ctx->key_bits);
- if (!ASN1_TYPE_set_int_octetstring(type, num,
- ctx->base.iv, ctx->base.ivlen)) {
+ num = rc2_keybits_to_magic((int)ctx->key_bits);
+ if (!ASN1_TYPE_set_int_octetstring(type, num, ctx->base.iv,
+ (int)ctx->base.ivlen)) {
ASN1_TYPE_free(type);
ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
return 0;
if (p->data_type != OSSL_PARAM_OCTET_STRING
|| ctx->base.ivlen > sizeof(iv)
- || (type = d2i_ASN1_TYPE(NULL, &d, p->data_size)) == NULL
+ || (type = d2i_ASN1_TYPE(NULL, &d, (long)p->data_size)) == NULL
|| ((size_t)ASN1_TYPE_get_int_octetstring(type, &num, iv,
- ctx->base.ivlen)
+ (int)ctx->base.ivlen)
!= ctx->base.ivlen)
|| !ossl_cipher_generic_initiv(&ctx->base, iv, ctx->base.ivlen)
|| (ctx->key_bits = rc2_magic_to_keybits(num)) == 0) {
{
PROV_RC4_HMAC_MD5_CTX *ctx = (PROV_RC4_HMAC_MD5_CTX *)bctx;
- RC4_set_key(&ctx->ks.ks, keylen, key);
+ RC4_set_key(&ctx->ks.ks, (int)keylen, key);
MD5_Init(&ctx->head); /* handy when benchmarking */
ctx->tail = ctx->head;
ctx->md = ctx->head;
blocks *= MD5_CBLOCK;
rc4_off += blocks;
md5_off += blocks;
- ctx->md.Nh += blocks >> 29;
- ctx->md.Nl += blocks <<= 3;
+ ctx->md.Nh += (unsigned int)(blocks >> 29);
+ ctx->md.Nl += (unsigned int)(blocks <<= 3);
if (ctx->md.Nl < (unsigned int)blocks)
ctx->md.Nh++;
} else {
if (l < ctx->md.Nl)
ctx->md.Nh++;
ctx->md.Nl = l;
- ctx->md.Nh += blocks >> 29;
+ ctx->md.Nh += (unsigned int)(blocks >> 29);
} else {
md5_off = 0;
rc4_off = 0;
{
PROV_RC4_CTX *rctx = (PROV_RC4_CTX *)ctx;
- RC4_set_key(&rctx->ks.ks, keylen, key);
+ RC4_set_key(&rctx->ks.ks, (int)keylen, key);
return 1;
}
{
PROV_RC5_CTX *rctx = (PROV_RC5_CTX *)ctx;
- return RC5_32_set_key(&rctx->ks.ks, keylen, key, rctx->rounds);
+ return RC5_32_set_key(&rctx->ks.ks, (int)keylen, key, rctx->rounds);
}
# define PROV_CIPHER_HW_rc5_mode(mode, UCMODE) \
#define SM4_HW_CCM_SET_KEY_FN(fn_set_enc_key, fn_blk, fn_ccm_enc, fn_ccm_dec) \
fn_set_enc_key(key, &actx->ks.ks); \
- CRYPTO_ccm128_init(&ctx->ccm_ctx, ctx->m, ctx->l, &actx->ks.ks, \
+ CRYPTO_ccm128_init(&ctx->ccm_ctx, (unsigned int)ctx->m, \
+ (unsigned int)ctx->l, &actx->ks.ks, \
(block128_f)fn_blk); \
ctx->str = ctx->enc ? (ccm128_f)fn_ccm_enc : (ccm128_f)fn_ccm_dec; \
ctx->key_set = 1;
if (inl < 24)
return -1;
if (out == NULL)
- return inl - 16;
+ return (int)(inl - 16);
memcpy(ctx->iv, wrap_iv, 8);
/* Decrypt first block which will end up as icv */
ctx->hw->cipher(ctx, icv, icv, 8);
if (ossl_sha1(out, inl - 16, sha1tmp) /* Work out hash of first portion */
&& CRYPTO_memcmp(sha1tmp, icv, 8) == 0)
- rv = inl - 16;
+ rv = (int)(inl - 16);
OPENSSL_cleanse(icv, 8);
OPENSSL_cleanse(sha1tmp, SHA_DIGEST_LENGTH);
OPENSSL_cleanse(iv, 8);
size_t icvlen = TDES_IVLEN;
size_t len = inl + ivlen + icvlen;
+ if (len > INT_MAX)
+ return 0;
if (out == NULL)
- return len;
+ return (int)len;
/* Copy input to output buffer + 8 so we have space for IV */
memmove(out + ivlen, in, inl);
BUF_reverse(out, NULL, len);
memcpy(ctx->iv, wrap_iv, ivlen);
ctx->hw->cipher(ctx, out, out, len);
- return len;
+ return (int)len;
}
static int tdes_wrap_cipher_internal(PROV_CIPHER_CTX *ctx, unsigned char *out,
ctx->buf[alen - 1] = (unsigned char)(len & 0xff);
/* Extra padding: tag appended to record. */
- return ctx->m;
+ return (int)ctx->m;
}
static int ccm_tls_iv_set_fixed(PROV_CCM_CTX *ctx, unsigned char *fixed,
*/
static int gcm_iv_generate(PROV_GCM_CTX *ctx, int offset)
{
- int sz = ctx->ivlen - offset;
+ int sz = (int)(ctx->ivlen - offset);
/* Must be at least 96 bits */
if (sz <= 0 || ctx->ivlen < GCM_IV_DEFAULT_SIZE)
{
uint8_t outbuffer[BLAKE2B_OUTBYTES] = {0};
uint8_t *target = outbuffer;
- int iter = (c->outlen + 7) / 8;
+ int iter = (int)((c->outlen + 7) / 8);
int i;
/* Avoid writing to the temporary buffer if possible */
uint32_t m[16];
uint32_t v[16];
size_t i;
- size_t increment;
+ uint32_t increment;
/*
* There are two distinct usage vectors for this function:
* including even zero), which is why following assignment doesn't
* have to reside inside the main loop below.
*/
- increment = len < BLAKE2S_BLOCKBYTES ? len : BLAKE2S_BLOCKBYTES;
+ increment = len < BLAKE2S_BLOCKBYTES ? (uint32_t)len : BLAKE2S_BLOCKBYTES;
for (i = 0; i < 8; ++i) {
v[i] = S->h[i];
{
uint8_t outbuffer[BLAKE2S_OUTBYTES] = {0};
uint8_t *target = outbuffer;
- int iter = (c->outlen + 3) / 4;
+ int iter = (int)((c->outlen + 3) / 4);
int i;
/* Avoid writing to the temporary buffer if possible */
p = OSSL_PARAM_locate_const(params, OSSL_DIGEST_PARAM_SSL3_MS);
if (p != NULL && p->data_type == OSSL_PARAM_OCTET_STRING)
return ossl_md5_sha1_ctrl(ctx, EVP_CTRL_SSL3_MASTER_SECRET,
- p->data_size, p->data);
+ (int)p->data_size, p->data);
return 1;
}
p = OSSL_PARAM_locate_const(params, OSSL_DIGEST_PARAM_SSL3_MS);
if (p != NULL && p->data_type == OSSL_PARAM_OCTET_STRING)
return ossl_sha1_ctrl(ctx, EVP_CTRL_SSL3_MASTER_SECRET,
- p->data_size, p->data);
+ (int)p->data_size, p->data);
return 1;
}
int new_der_len = 0;
X509_SIG_get0(p8, &alg, &oct);
- if (!PKCS12_pbe_crypt_ex(alg, pbuf, plen,
+ if (!PKCS12_pbe_crypt_ex(alg, pbuf, (int)plen,
oct->data, oct->length,
&new_der, &new_der_len, 0,
libctx, propq)) {
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;
}
return 0;
*pder = keyblob;
- return ecxkey->keylen;
+ return (int)ecxkey->keylen;
}
static int ecx_pki_priv_to_der(const void *vecxkey, unsigned char **pder,
}
oct.data = ecxkey->privkey;
- oct.length = ecxkey->keylen;
+ oct.length = (int)ecxkey->keylen;
oct.flags = 0;
keybloblen = i2d_ASN1_OCTET_STRING(&oct, pder);
return 0;
*pder = key_blob;
- return key_len;
+ return (int)key_len;
}
static int slh_dsa_pki_priv_to_der(const void *vkey, unsigned char **pder,
&& ((*pder = OPENSSL_memdup(ossl_slh_dsa_key_get_priv(key), len)) == NULL))
return 0;
- return len;
+ return (int)len;
}
# define slh_dsa_epki_priv_to_der slh_dsa_pki_priv_to_der
params->alg);
goto end;
}
- len = p8fmt->p8_bytes;
+ len = (int)p8fmt->p8_bytes;
if (out == NULL) {
ret = len;
goto end;
}
- if ((pos = buf = OPENSSL_malloc((size_t) len)) == NULL)
+ if ((pos = buf = OPENSSL_malloc((size_t)len)) == NULL)
goto end;
switch (p8fmt->p8_shift) {
v->algorithm_name);
goto end;
}
- len = p8fmt->p8_bytes;
+ len = (int)p8fmt->p8_bytes;
if (out == NULL) {
ret = len;
goto end;
}
- if ((pos = buf = OPENSSL_malloc((size_t) len)) == NULL)
+ if ((pos = buf = OPENSSL_malloc((size_t)len)) == NULL)
goto end;
switch (p8fmt->p8_shift) {
int ossl_gcm_cipher_update(PROV_GCM_CTX *ctx, const unsigned char *in,
size_t len, unsigned char *out);
-# define GCM_HW_SET_KEY_CTR_FN(ks, fn_set_enc_key, fn_block, fn_ctr) \
- fn_set_enc_key(key, keylen * 8, ks); \
+# define GCM_HW_SET_KEY_CTR_FN(ks, fn_set_enc_key, fn_block, fn_ctr) \
+ fn_set_enc_key(key, (int)(keylen * 8), ks); \
CRYPTO_gcm128_init(&ctx->gcm, ks, (block128_f)fn_block); \
ctx->ctr = (ctr128_f)fn_ctr; \
ctx->key_set = 1;
if ((hmac = HMAC_CTX_new()) == NULL)
return 0;
- if (!HMAC_Init_ex(hmac, prk, prk_len, evp_md, NULL))
+ if (!HMAC_Init_ex(hmac, prk, (int)prk_len, evp_md, NULL))
goto err;
for (i = 1; i <= n; i++) {
}
if (ctx->use_l != 0)
- l = be32(keylen * 8);
+ l = be32((uint32_t)(keylen * 8));
k_i = OPENSSL_zalloc(h);
if (k_i == NULL)
* finally add carry if any
*/
static void n_fold(unsigned char *block, unsigned int blocksize,
- const unsigned char *constant, size_t constant_len)
+ const unsigned char *constant, unsigned int constant_len)
{
unsigned int tmp, gcd, remainder, lcm, carry;
int b, l;
/* set the key len for the odd variable key len cipher */
klen = EVP_CIPHER_CTX_get_key_length(ctx);
if (key_len != (size_t)klen) {
- ret = EVP_CIPHER_CTX_set_key_length(ctx, key_len);
+ ret = EVP_CIPHER_CTX_set_key_length(ctx, (int)key_len);
if (ret <= 0) {
ret = 0;
goto out;
goto out;
}
- n_fold(block, blocksize, constant, constant_len);
+ n_fold(block, (unsigned int)blocksize, constant, (unsigned int)constant_len);
plainblock = block;
cipherblock = block + EVP_MAX_BLOCK_LENGTH;
int olen;
ret = EVP_EncryptUpdate(ctx, cipherblock, &olen,
- plainblock, blocksize);
+ plainblock, (int)blocksize);
if (!ret)
goto out;
cipherlen = olen;
md = ossl_prov_digest_md(&ctx->digest);
return pbkdf2_derive(ctx, (char *)ctx->pass, ctx->pass_len,
- ctx->salt, ctx->salt_len, ctx->iter,
+ ctx->salt, (int)ctx->salt_len, ctx->iter,
md, key, keylen, ctx->lower_bound_checks);
}
return 0;
if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_SALT)) != NULL) {
- if (!lower_bound_check_passed(ctx, p->data_size, UINT64_MAX, SIZE_MAX,
+ if (!lower_bound_check_passed(ctx, (int)p->data_size, UINT64_MAX, SIZE_MAX,
ctx->lower_bound_checks))
return 0;
if (!pbkdf2_set_membuf(&ctx->salt, &ctx->salt_len, p))
if (hctx_tpl == NULL)
return 0;
p = key;
- tkeylen = keylen;
- if (!HMAC_Init_ex(hctx_tpl, pass, passlen, digest, NULL))
+ tkeylen = (int)keylen;
+ if (!HMAC_Init_ex(hctx_tpl, pass, (int)passlen, digest, NULL))
goto err;
hctx = HMAC_CTX_new();
if (hctx == NULL)
X = (uint32_t *)(B + Blen);
T = X + 32 * r;
V = T + 32 * r;
- if (ossl_pkcs5_pbkdf2_hmac_ex(pass, passlen, salt, saltlen, 1, sha256,
- (int)Blen, B, libctx, propq) == 0)
+ if (ossl_pkcs5_pbkdf2_hmac_ex(pass, (int)passlen, salt, (int)saltlen, 1,
+ sha256, (int)Blen, B, libctx, propq) == 0)
goto err;
for (i = 0; i < p; i++)
scryptROMix(B + 128 * r * i, r, N, X, T, V);
- if (ossl_pkcs5_pbkdf2_hmac_ex(pass, passlen, B, (int)Blen, 1, sha256,
- keylen, key, libctx, propq) == 0)
+ if (ossl_pkcs5_pbkdf2_hmac_ex(pass, (int)passlen, B, (int)Blen, 1, sha256,
+ (int)keylen, key, libctx, propq) == 0)
goto err;
rv = 1;
err:
/* keylenbits must fit into 4 bytes */
if (keylen > 0xFFFFFF)
return 0;
- keylen_bits = 8 * keylen;
+ keylen_bits = (uint32_t)(8 * keylen);
/* Calculate the size of the buffer */
if (!der_encode_sharedinfo(&pkt, NULL, 0, cek_oid, cek_oid_len,
&counter, 1))
goto err;
privbuf[0] &= info->bitmask;
- if (BN_bin2bn(privbuf, info->Nsk, priv) == NULL)
+ if (BN_bin2bn(privbuf, (int)info->Nsk, priv) == NULL)
goto err;
if (counter == 0xFF) {
ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GENERATE_KEY);
size_t encodedprivlen = info->Nsk;
int auth = ctx->sender_authkey != NULL;
- if (!generate_ecdhkm(privkey1, peerkey1, dhkm, sizeof(dhkm), encodedprivlen))
+ if (!generate_ecdhkm(privkey1, peerkey1, dhkm, sizeof(dhkm),
+ (unsigned int)encodedprivlen))
goto err;
dhkmlen = encodedprivlen;
kemctxlen = 2 * encodedpublen;
}
if (!generate_ecdhkm(privkey2, peerkey2,
dhkm + dhkmlen, sizeof(dhkm) - dhkmlen,
- encodedprivlen))
+ (unsigned int)encodedprivlen))
goto err;
dhkmlen += encodedprivlen;
kemctxlen += encodedpublen;
int auth = ctx->sender_authkey != NULL;
size_t encodedkeylen = info->Npk;
- if (!generate_ecxdhkm(privkey1, peerkey1, dhkm, sizeof(dhkm), encodedkeylen))
+ if (!generate_ecxdhkm(privkey1, peerkey1, dhkm, sizeof(dhkm),
+ (unsigned int)encodedkeylen))
goto err;
dhkmlen = encodedkeylen;
if (auth) {
if (!generate_ecxdhkm(privkey2, peerkey2,
dhkm + dhkmlen, sizeof(dhkm) - dhkmlen,
- encodedkeylen))
+ (unsigned int)encodedkeylen))
goto err;
/* Get the public key of the auth sender in encoded form */
sender_authpub = ecx_pubkey(ctx->sender_authkey);
* Step (2): Generate a random byte string z of nlen bytes where
* 1 < z < n - 1
*/
- if (!rsasve_gen_rand_bytes(prsactx->rsa, secret, nlen))
+ if (!rsasve_gen_rand_bytes(prsactx->rsa, secret, (int)nlen))
return 0;
/* Step(3): out = RSAEP((n,e), z) */
- ret = RSA_public_encrypt(nlen, secret, out, prsactx->rsa, RSA_NO_PADDING);
+ ret = RSA_public_encrypt((int)nlen, secret, out, prsactx->rsa,
+ RSA_NO_PADDING);
if (ret) {
ret = 1;
if (outlen != NULL)
}
/* Step (3): out = RSADP((n,d), in) */
- ret = RSA_private_decrypt(inlen, in, out, prsactx->rsa, RSA_NO_PADDING);
+ ret = RSA_private_decrypt((int)inlen, in, out, prsactx->rsa, RSA_NO_PADDING);
if (ret > 0 && outlen != NULL)
*outlen = ret;
return ret > 0;
&& gctx->ffc_params == NULL) {
/* Select a named group if there is not one already */
if (gctx->group_nid == NID_undef)
- gctx->group_nid = ossl_dh_get_named_group_uid_from_size(gctx->pbits);
+ gctx->group_nid = ossl_dh_get_named_group_uid_from_size((int)gctx->pbits);
if (gctx->group_nid == NID_undef)
return NULL;
dh = ossl_dh_new_by_nid_ex(gctx->libctx, gctx->group_nid);
* group based on pbits.
*/
if (gctx->gen_type == DH_PARAMGEN_TYPE_GENERATOR)
- ret = DH_generate_parameters_ex(dh, gctx->pbits,
+ ret = DH_generate_parameters_ex(dh, (int)gctx->pbits,
gctx->generator, gencb);
else
ret = ossl_dh_generate_ffc_parameters(dh, gctx->gen_type,
- gctx->pbits, gctx->qbits,
- gencb);
+ (int)gctx->pbits,
+ (int)gctx->qbits, gencb);
if (ret <= 0)
goto end;
}
if ((gctx->selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0) {
if (ossl_dsa_generate_ffc_parameters(dsa, gctx->gen_type,
- gctx->pbits, gctx->qbits,
- gencb) <= 0)
+ (int)gctx->pbits,
+ (int)gctx->qbits, gencb) <= 0)
goto end;
}
ossl_ffc_params_enable_flags(ffc, FFC_PARAM_FLAG_VALIDATE_LEGACY,
struct ml_dsa_get_params_st p = ml_dsa_get_params_decoder(params);
if (p.bits != NULL
- && !OSSL_PARAM_set_int(p.bits, 8 * ossl_ml_dsa_key_get_pub_len(key)))
+ && !OSSL_PARAM_set_size_t(p.bits, 8 * ossl_ml_dsa_key_get_pub_len(key)))
return 0;
if (p.secbits != NULL
- && !OSSL_PARAM_set_int(p.secbits, ossl_ml_dsa_key_get_collision_strength_bits(key)))
+ && !OSSL_PARAM_set_size_t(p.secbits, ossl_ml_dsa_key_get_collision_strength_bits(key)))
return 0;
if (p.maxsize != NULL
- && !OSSL_PARAM_set_int(p.maxsize, ossl_ml_dsa_key_get_sig_len(key)))
+ && !OSSL_PARAM_set_size_t(p.maxsize, ossl_ml_dsa_key_get_sig_len(key)))
return 0;
if (p.seccat != NULL
const ML_KEM_VINFO *v = ossl_ml_kem_key_vinfo(key);
struct ml_kem_get_params_st p = ml_kem_get_params_decoder(params);
- if (p.bits != NULL && !OSSL_PARAM_set_int(p.bits, v->bits))
+ if (p.bits != NULL && !OSSL_PARAM_set_size_t(p.bits, v->bits))
return 0;
- if (p.secbits != NULL && !OSSL_PARAM_set_int(p.secbits, v->secbits))
+ if (p.secbits != NULL && !OSSL_PARAM_set_size_t(p.secbits, v->secbits))
return 0;
- if (p.maxsize != NULL && !OSSL_PARAM_set_int(p.maxsize, v->ctext_bytes))
+ if (p.maxsize != NULL && !OSSL_PARAM_set_size_t(p.maxsize, v->ctext_bytes))
return 0;
if (p.seccat != NULL && !OSSL_PARAM_set_int(p.seccat, v->security_category))
/* Ignore public keys when private provided */
if (!load_slot(key->libctx, key->propq, OSSL_PKEY_PARAM_PRIV_KEY,
minimal_selection, key, slot, prvenc,
- key->minfo->prvkey_bytes, key->xinfo->prvkey_bytes))
+ (int)key->minfo->prvkey_bytes,
+ (int)key->xinfo->prvkey_bytes))
goto err;
} else if (publen) {
/* Absent private key data, import public keys */
if (!load_slot(key->libctx, key->propq, OSSL_PKEY_PARAM_PUB_KEY,
minimal_selection, key, slot, pubenc,
- key->minfo->pubkey_bytes, key->xinfo->pubkey_bytes))
+ (int)key->minfo->pubkey_bytes,
+ (int)key->xinfo->pubkey_bytes))
goto err;
}
}
/* The ciphertext sizes are additive */
if (p.maxsize != NULL)
- if (!OSSL_PARAM_set_int(p.maxsize, key->minfo->ctext_bytes + key->xinfo->pubkey_bytes))
+ if (!OSSL_PARAM_set_size_t(p.maxsize, key->minfo->ctext_bytes + key->xinfo->pubkey_bytes))
return 0;
if (!mlx_kem_have_pubkey(key))
const uint8_t *pub, *priv;
if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
- && !OSSL_PARAM_set_int(p, 8 * ossl_slh_dsa_key_get_pub_len(key)))
+ && !OSSL_PARAM_set_size_t(p, 8 * ossl_slh_dsa_key_get_pub_len(key)))
return 0;
if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
- && !OSSL_PARAM_set_int(p, 8 * ossl_slh_dsa_key_get_n(key)))
+ && !OSSL_PARAM_set_size_t(p, 8 * ossl_slh_dsa_key_get_n(key)))
return 0;
if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
- && !OSSL_PARAM_set_int(p, ossl_slh_dsa_key_get_sig_len(key)))
+ && !OSSL_PARAM_set_size_t(p, ossl_slh_dsa_key_get_sig_len(key)))
return 0;
if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_CATEGORY)) != NULL
&& !OSSL_PARAM_set_int(p, ossl_slh_dsa_key_get_security_category(key)))
data += INT_MAX;
datalen -= INT_MAX;
}
- return EVP_EncryptUpdate(ctx, NULL, &outlen, data, datalen);
+ return EVP_EncryptUpdate(ctx, NULL, &outlen, data, (int)datalen);
}
static int gmac_final(void *vmacctx, unsigned char *out, size_t *outl,
if (!EVP_EncryptFinal_ex(macctx->ctx, out, &hlen))
return 0;
- hlen = gmac_size();
+ hlen = (int)gmac_size();
params[0] = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG,
out, (size_t)hlen);
if (!EVP_CIPHER_CTX_get_params(macctx->ctx, params))
return 0;
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,
- p->data_size, NULL) <= 0
+ (int)p->data_size, NULL) <= 0
|| !EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, p->data))
return 0;
}
digest = ossl_prov_digest_md(&macctx->digest);
/* HMAC_Init_ex doesn't tolerate all zero params, so we must be careful */
if (key != NULL || (macctx->tls_data_size == 0 && digest != NULL))
- return HMAC_Init_ex(macctx->ctx, key, keylen, digest,
+ return HMAC_Init_ex(macctx->ctx, key, (int)keylen, digest,
ossl_prov_digest_engine(&macctx->digest));
return 1;
}
const unsigned char *in1, size_t in1_len,
const unsigned char *in2, size_t in2_len, size_t w)
{
- int len;
+ size_t len;
unsigned char *p = out;
- int sz = w;
+ size_t sz = w;
if (out == NULL) {
if (out_len == NULL) {
{
unsigned char *nonce = NULL, *entropy = NULL;
size_t noncelen = 0, entropylen = 0;
- size_t min_entropy, min_entropylen, max_entropylen;
+ unsigned int min_entropy;
+ size_t min_entropylen, max_entropylen;
if (strength > drbg->strength) {
ERR_raise(ERR_LIB_PROV, PROV_R_INSUFFICIENT_DRBG_STRENGTH);
* requests in 2^30 byte chunks, which is the greatest multiple
* of AES block size lower than or equal to 2^31-1.
*/
- buflen = outlen > (1U << 30) ? (1U << 30) : outlen;
+ buflen = outlen > (1U << 30) ? (1 << 30) : (int)outlen;
blocks = (buflen + 15) / 16;
ctr32 = GETU32(ctr->V + 12) + blocks;
goto err;
}
- drbg->strength = keylen * 8;
+ drbg->strength = (unsigned int)(keylen * 8);
drbg->seedlen = keylen + 16;
if (ctr->use_df) {
return 0;
hash->blocklen = md_size;
/* See SP800-57 Part1 Rev4 5.6.1 Table 3 */
- ctx->strength = 64 * (hash->blocklen >> 3);
+ ctx->strength = (unsigned int)(64 * (hash->blocklen >> 3));
if (ctx->strength > 256)
ctx->strength = 256;
if (hash->blocklen > MAX_BLOCKLEN_USING_SMALL_SEEDLEN)
{
CRNG_TEST *crngt = (CRNG_TEST *)vcrngt;
size_t n;
- int r = 0;
+ size_t r = 0;
/* Without a parent, we rely on the up calls */
if (crngt->parent == NULL
/* poll the CryptoAPI PRNG */
if (CryptAcquireContextW(&hProvider, NULL, NULL, PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT | CRYPT_SILENT) != 0) {
- if (CryptGenRandom(hProvider, bytes_needed, buffer) != 0)
- bytes = bytes_needed;
+ if (CryptGenRandom(hProvider, (DWORD)bytes_needed, buffer) != 0)
+ bytes = (DWORD)bytes_needed;
CryptReleaseContext(hProvider, 0);
}
if (CryptAcquireContextW(&hProvider, NULL,
INTEL_DEF_PROV, PROV_INTEL_SEC,
CRYPT_VERIFYCONTEXT | CRYPT_SILENT) != 0) {
- if (CryptGenRandom(hProvider, bytes_needed, buffer) != 0)
- bytes = bytes_needed;
+ if (CryptGenRandom(hProvider, (DWORD)bytes_needed, buffer) != 0)
+ bytes = (DWORD)bytes_needed;
CryptReleaseContext(hProvider, 0);
}
if (mdsize != 0 && tbslen != mdsize)
return 0;
- ret = ossl_dsa_sign_int(0, tbs, tbslen, sig, &sltmp, pdsactx->dsa,
+ ret = ossl_dsa_sign_int(0, tbs, (int)tbslen, sig, &sltmp, pdsactx->dsa,
pdsactx->nonce_type, pdsactx->mdname,
pdsactx->libctx, pdsactx->propq);
if (ret <= 0)
if (!ossl_prov_is_running() || (mdsize != 0 && tbslen != mdsize))
return 0;
- return DSA_verify(0, tbs, tbslen, sig, siglen, pdsactx->dsa);
+ return DSA_verify(0, tbs, (int)tbslen, sig, (int)siglen, pdsactx->dsa);
}
static int dsa_verify_set_sig(void *vpdsactx,
if (ctx->mdname[0] != '\0')
mdname = ctx->mdname;
- ret = ossl_ecdsa_deterministic_sign(tbs, tbslen, sig, &sltmp,
+ ret = ossl_ecdsa_deterministic_sign(tbs, (int)tbslen, sig, &sltmp,
ctx->ec, ctx->nonce_type,
mdname,
ctx->libctx, ctx->propq);
} else {
- ret = ECDSA_sign_ex(0, tbs, tbslen, sig, &sltmp, ctx->kinv, ctx->r,
- ctx->ec);
+ ret = ECDSA_sign_ex(0, tbs, (int)tbslen, sig, &sltmp,
+ ctx->kinv, ctx->r, ctx->ec);
}
if (ret <= 0)
return 0;
if (!ossl_prov_is_running() || (ctx->mdsize != 0 && tbslen != ctx->mdsize))
return 0;
- return ECDSA_verify(0, tbs, tbslen, sig, siglen, ctx->ec);
+ return ECDSA_verify(0, tbs, (int)tbslen, sig, (int)siglen, ctx->ec);
}
static int ecdsa_verify_set_sig(void *vctx,
/* True if PSS parameters are restricted */
#define rsa_pss_restricted(prsactx) (prsactx->min_saltlen != -1)
-static size_t rsa_get_md_size(const PROV_RSA_CTX *prsactx)
+static int rsa_get_md_size(const PROV_RSA_CTX *prsactx)
{
int md_size;
"only PKCS#1 padding supported with MDC2");
return 0;
}
- ret = RSA_sign_ASN1_OCTET_STRING(0, tbs, tbslen, sig, &sltmp,
- prsactx->rsa);
+ ret = RSA_sign_ASN1_OCTET_STRING(0, tbs, (unsigned int)tbslen, sig,
+ &sltmp, prsactx->rsa);
if (ret <= 0) {
ERR_raise(ERR_LIB_PROV, ERR_R_RSA_LIB);
}
memcpy(prsactx->tbuf, tbs, tbslen);
prsactx->tbuf[tbslen] = RSA_X931_hash_id(prsactx->mdnid);
- ret = RSA_private_encrypt(tbslen + 1, prsactx->tbuf,
+ ret = RSA_private_encrypt((int)(tbslen + 1), prsactx->tbuf,
sig, prsactx->rsa, RSA_X931_PADDING);
clean_tbuf(prsactx);
break;
{
unsigned int sltmp;
- ret = RSA_sign(prsactx->mdnid, tbs, tbslen, sig, &sltmp,
- prsactx->rsa);
+ ret = RSA_sign(prsactx->mdnid, tbs, (unsigned int)tbslen,
+ sig, &sltmp, prsactx->rsa);
if (ret <= 0) {
ERR_raise(ERR_LIB_PROV, ERR_R_RSA_LIB);
return 0;
return 0;
}
} else {
- ret = RSA_private_encrypt(tbslen, tbs, sig, prsactx->rsa,
+ ret = RSA_private_encrypt((int)tbslen, tbs, sig, prsactx->rsa,
prsactx->pad_mode);
}
case RSA_X931_PADDING:
if (!setup_tbuf(prsactx))
return 0;
- ret = RSA_public_decrypt(siglen, sig, prsactx->tbuf, prsactx->rsa,
+ ret = RSA_public_decrypt((int)siglen, sig, prsactx->tbuf, prsactx->rsa,
RSA_X931_PADDING);
if (ret < 1) {
ERR_raise(ERR_LIB_PROV, ERR_R_RSA_LIB);
ERR_raise(ERR_LIB_PROV, ERR_R_RSA_LIB);
return 0;
}
- ret = sltmp;
+ ret = (int)sltmp;
}
break;
return 0;
}
} else {
- ret = RSA_public_decrypt(siglen, sig, rout, prsactx->rsa,
+ ret = RSA_public_decrypt((int)siglen, sig, rout, prsactx->rsa,
prsactx->pad_mode);
if (ret < 0) {
ERR_raise(ERR_LIB_PROV, ERR_R_RSA_LIB);
if (prsactx->md != NULL) {
switch (prsactx->pad_mode) {
case RSA_PKCS1_PADDING:
- if (!RSA_verify(prsactx->mdnid, tbs, tbslen, sig, siglen,
- prsactx->rsa)) {
+ if (!RSA_verify(prsactx->mdnid, tbs, (unsigned int)tbslen,
+ sig, (unsigned int)siglen, prsactx->rsa)) {
ERR_raise(ERR_LIB_PROV, ERR_R_RSA_LIB);
return 0;
}
if (!setup_tbuf(prsactx))
return 0;
- ret = RSA_public_decrypt(siglen, sig, prsactx->tbuf,
+ ret = RSA_public_decrypt((int)siglen, sig, prsactx->tbuf,
prsactx->rsa, RSA_NO_PADDING);
if (ret <= 0) {
ERR_raise(ERR_LIB_PROV, ERR_R_RSA_LIB);
if (!setup_tbuf(prsactx))
return 0;
- ret = RSA_public_decrypt(siglen, sig, prsactx->tbuf, prsactx->rsa,
+ ret = RSA_public_decrypt((int)siglen, sig, prsactx->tbuf, prsactx->rsa,
prsactx->pad_mode);
if (ret <= 0) {
ERR_raise(ERR_LIB_PROV, ERR_R_RSA_LIB);
if (ctx->mdsize != 0 && tbslen != ctx->mdsize)
return 0;
- ret = ossl_sm2_internal_sign(tbs, tbslen, sig, &sltmp, ctx->ec);
+ ret = ossl_sm2_internal_sign(tbs, (int)tbslen, sig, &sltmp, ctx->ec);
if (ret <= 0)
return 0;
if (ctx->mdsize != 0 && tbslen != ctx->mdsize)
return 0;
- return ossl_sm2_internal_verify(tbs, tbslen, sig, siglen, ctx->ec);
+ return ossl_sm2_internal_verify(tbs, (int)tbslen, sig, (int)siglen, ctx->ec);
}
static void free_md(PROV_SM2_CTX *ctx)
int ok = 0;
if (!OSSL_PARAM_get_octet_string_ptr(p, (const void **)&der, &der_len)
- || (x509_name = d2i_X509_NAME(NULL, &der, der_len)) == NULL)
+ || der_len > LONG_MAX
+ || (x509_name = d2i_X509_NAME(NULL, &der, (long)der_len)) == NULL)
return 0;
if (ctx->type != IS_DIR) {
char *str = X509_NAME_oneline(x509_name, NULL, 0);
assert(name != NULL);
{
const char *pathsep = ossl_ends_with_dirsep(ctx->uri) ? "" : "/";
- long calculated_length = strlen(ctx->uri) + strlen(pathsep)
+ size_t calculated_length = strlen(ctx->uri) + strlen(pathsep)
+ strlen(name) + 1 /* \0 */;
data = OPENSSL_zalloc(calculated_length);
}
ERR_set_mark();
- ok = BIO_read(in, &mem->data[0], mem_want) == (int)mem_want;
+ ok = BIO_read(in, &mem->data[0], (int)mem_want) == (int)mem_want;
mem_len += mem_want;
ERR_pop_to_mark();
if (!ok)
}
ERR_set_mark();
- ok = BIO_read(in, &mem->data[mem_len], mem_want) == (int)mem_want;
+ ok = BIO_read(in, &mem->data[mem_len], (int)mem_want) == (int)mem_want;
mem_len += mem_want;
ERR_pop_to_mark();
}
ERR_set_mark();
- ok = BIO_read(in, &mem->data[0], mem_want) == (int)mem_want;
+ ok = BIO_read(in, &mem->data[0], (int)mem_want) == (int)mem_want;
mem_len += mem_want;
ERR_pop_to_mark();
if (!ok)
}
ERR_set_mark();
- ok = BIO_read(in, &mem->data[mem_len], mem_want) == (int)mem_want;
+ ok = BIO_read(in, &mem->data[mem_len], (int)mem_want) == (int)mem_want;
mem_len += mem_want;
ERR_pop_to_mark();
if (ctx->state == STATE_EOF)
return;
- name.cbData = ctx->subject_len;
+ name.cbData = (DWORD)ctx->subject_len;
name.pbData = ctx->subject;
ctx->win_ctx = (name.cbData == 0 ? NULL :
projects / thirdparty / openssl.git / commitdiff
