}
BIO_puts(bio_out, "'");
if (len > 0)
- BIO_write(bio_out, s, len);
+ BIO_write(bio_out, s, (int)len);
BIO_puts(bio_out, "'\n");
}
BIO *out = NULL;
int ret = 0;
ASN1_INTEGER *ai = NULL;
- int j;
+ size_t j;
if (suffix == NULL)
j = strlen(serialfile);
const char *old_suffix)
{
char buf[2][BSIZE];
- int i, j;
+ size_t i, j;
i = strlen(serialfile) + strlen(old_suffix);
j = strlen(serialfile) + strlen(new_suffix);
BIO *out;
int j;
- j = strlen(dbfile) + strlen(suffix);
+ j = (int)(strlen(dbfile) + strlen(suffix));
if (j + 6 >= BSIZE) {
BIO_printf(bio_err, "File name too long\n");
goto err;
const char *old_suffix)
{
char buf[5][BSIZE];
- int i, j;
+ size_t i, j;
i = strlen(dbfile) + strlen(old_suffix);
j = strlen(dbfile) + strlen(new_suffix);
continue;
}
if (!X509_NAME_add_entry_by_NID(n, nid, chtype,
- valstr, strlen((char *)valstr),
+ valstr, (int)strlen((char *)valstr),
-1, ismulti ? -1 : 0)) {
ERR_print_errors(bio_err);
BIO_printf(bio_err,
goto err;
tto = tfrom + flen;
# if !defined(_WIN32_WCE) || _WIN32_WCE >= 101
- if (!MultiByteToWideChar(CP_ACP, 0, from, flen, (WCHAR *)tfrom, flen))
+ if (!MultiByteToWideChar(CP_ACP, 0, from, (int)flen, (WCHAR *)tfrom, (int)flen))
# endif
for (i = 0; i < flen; i++)
tfrom[i] = (TCHAR)from[i];
# if !defined(_WIN32_WCE) || _WIN32_WCE >= 101
- if (!MultiByteToWideChar(CP_ACP, 0, to, tlen, (WCHAR *)tto, tlen))
+ if (!MultiByteToWideChar(CP_ACP, 0, to, (int)tlen, (WCHAR *)tto, (int)tlen))
# endif
for (i = 0; i < tlen; i++)
tto[i] = (TCHAR)to[i];
out = bio_open_owner(filename, format, private);
if (out == NULL)
goto end;
- rv = BIO_write(out, mem_buffer->data, mem_buffer->length);
+ rv = BIO_write(out, mem_buffer->data, (int)mem_buffer->length);
if (rv < 0 || (size_t)rv != mem_buffer->length)
BIO_printf(bio_err, "Error writing to output file: '%s'\n", filename);
else
OPENSSL_clear_free(buff, (unsigned int)bufsiz);
if (ok >= 0)
- res = strlen(buf);
+ res = (int)strlen(buf);
if (ok == -1) {
BIO_printf(bio_err, "User interface error\n");
ERR_print_errors(bio_err);
for (f = functions; f->name != NULL; ++f)
if (f->type == FT_general || f->type == FT_md || f->type == FT_cipher)
- if ((len = strlen(f->name)) > maxlen)
+ if ((len = (int)strlen(f->name)) > maxlen)
maxlen = len;
dc->width = maxlen + 2;
i = 2 + (int)strlen(o->name);
if (o->valtype != '-')
- i += 1 + strlen(valtype2param(o));
+ i += 1 + (int)strlen(valtype2param(o));
if (i > width)
width = i;
return -1;
# if !defined(_WIN32_WCE) || _WIN32_WCE>=101
- if (!MultiByteToWideChar(CP_ACP, 0, name, len_0, tempname, MAX_PATH))
+ if (!MultiByteToWideChar(CP_ACP, 0, name, (int)len_0, tempname, MAX_PATH))
# endif
for (i = 0; i < len_0; i++)
tempname[i] = (WCHAR)name[i];
BIO_printf(out, "read from %p [%p] (%zu bytes => %zu (0x%zX))\n",
(void *)bio, (void *)msg->data, msg->data_len,
msg->data_len, msg->data_len);
- BIO_dump(out, msg->data, msg->data_len);
+ if (msg->data_len <= INT_MAX)
+ BIO_dump(out, msg->data, (int)msg->data_len);
}
} else if (mmsgargs->num_msg > 0) {
BIO_MSG *msg = mmsgargs->msg;
BIO_printf(out, "write to %p [%p] (%zu bytes => %zu (0x%zX))\n",
(void *)bio, (void *)msg->data, msg->data_len,
msg->data_len, msg->data_len);
- BIO_dump(out, msg->data, msg->data_len);
+ if (msg->data_len <= INT_MAX)
+ BIO_dump(out, msg->data, (int)msg->data_len);
}
} else if (mmsgargs->num_msg > 0) {
BIO_MSG *msg = mmsgargs->msg;
/*
* make a copy of the command line, since we might have to modify it...
*/
- wlen = wcslen(wcmdline);
+ wlen = (int)wcslen(wcmdline);
p = _alloca((wlen + 1) * sizeof(WCHAR));
- wcscpy(p, wcmdline);
+ memcpy(p, wcmdline, (wlen + 1) * sizeof(WCHAR));
while (*p != L'\0') {
int in_quote = 0;
*/
{
const WCHAR *q = p;
- int i;
+ size_t i;
while (*p == L'\\')
p++;
if (*p == L'"') {
- int i;
-
for (i = (p - q) / 2; i > 0; i--)
*wend++ = L'\\';
}
}
- wlen = wend - warg;
+ wlen = (int)(wend - warg);
if (wlen == 0 || !process_glob(warg, wlen)) {
if (!validate_argv(newargc + 1)) {
do {
# ifdef CP_UTF8
if ((sz = MultiByteToWideChar((cp = CP_UTF8), 0,
- directory, len_0,
+ directory, (int)len_0,
NULL, 0)) > 0 ||
GetLastError() != ERROR_NO_UNICODE_TRANSLATION)
break;
# endif
sz = MultiByteToWideChar((cp = CP_ACP), 0,
- directory, len_0,
+ directory, (int)len_0,
NULL, 0);
} while (0);
* concatenate asterisk, |sz| covers trailing '\0'!
*/
wdir = _alloca((sz + 2) * sizeof(TCHAR));
- if (!MultiByteToWideChar(cp, 0, directory, len_0,
+ if (!MultiByteToWideChar(cp, 0, directory, (int)len_0,
(WCHAR *)wdir, sz)) {
free(*ctx);
*ctx = NULL;
} else
#endif
{
- sz = len_0;
+ sz = (int)len_0;
/*
* allocate two additional characters in case we need to
* concatenate asterisk, |sz| covers trailing '\0'!
len_0++;
#ifdef LP_MULTIBYTE_AVAILABLE
- if (!WideCharToMultiByte(CP_DEFAULT, 0, (WCHAR *)wdir, len_0,
+ if (!WideCharToMultiByte(CP_DEFAULT, 0, (WCHAR *)wdir, (int)len_0,
(*ctx)->entry_name,
sizeof((*ctx)->entry_name), NULL, 0))
#endif
unsigned char *out,
const unsigned char *in, unsigned int inlen)
{
- return CRYPTO_128_wrap(key, iv, out, in, inlen, (block128_f) AES_encrypt);
+ return (int)CRYPTO_128_wrap(key, iv, out, in, inlen, (block128_f) AES_encrypt);
}
int AES_unwrap_key(AES_KEY *key, const unsigned char *iv,
unsigned char *out,
const unsigned char *in, unsigned int inlen)
{
- return CRYPTO_128_unwrap(key, iv, out, in, inlen,
- (block128_f) AES_decrypt);
+ return (int)CRYPTO_128_unwrap(key, iv, out, in, inlen,
+ (block128_f) AES_decrypt);
}
{
BUF_MEM *b;
unsigned char *p;
- int i;
size_t want = HEADER_SIZE;
uint32_t eos = 0;
size_t off = 0;
for (;;) {
diff = len - off;
if (want >= diff) {
+ int i;
+
want -= diff;
if (len + want < len || !BUF_MEM_grow_clean(b, len + want)) {
ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
goto err;
}
- i = BIO_read(in, &(b->data[len]), want);
+ i = BIO_read(in, &(b->data[len]), (int)want);
if (i < 0 && diff == 0) {
ERR_raise(ERR_LIB_ASN1, ASN1_R_NOT_ENOUGH_DATA);
goto err;
diff = len - off;
if (diff == 0)
goto err;
- inf = ASN1_get_object(&q, &slen, &tag, &xclass, diff);
+ inf = ASN1_get_object(&q, &slen, &tag, &xclass, (int)diff);
if (inf & 0x80) {
unsigned long e;
goto err;
ERR_pop_to_mark();
}
- i = q - p; /* header length */
- off += i; /* end of data */
+ off += q - p; /* end of data */
if (inf & 1) {
/* no data body so go round again */
* in one go.
*/
size_t chunk = want > chunk_max ? chunk_max : want;
+ int i;
if (!BUF_MEM_grow_clean(b, len + chunk)) {
ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
}
want -= chunk;
while (chunk > 0) {
- i = BIO_read(in, &(b->data[len]), chunk);
+ i = BIO_read(in, &(b->data[len]), (int)chunk);
if (i <= 0) {
ERR_raise(ERR_LIB_ASN1, ASN1_R_NOT_ENOUGH_DATA);
goto err;
}
*pb = b;
- return off;
+ return (int)off;
err:
ERR_clear_last_mark();
BUF_MEM_free(b);
int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str)
{
ASN1_GENERALIZEDTIME t;
+ size_t len;
+
+ if ((len = strlen(str)) >= INT_MAX)
+ return 0;
t.type = V_ASN1_GENERALIZEDTIME;
- t.length = strlen(str);
+ t.length = (int)len;
t.data = (unsigned char *)str;
t.flags = 0;
int ossl_i2c_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **pp)
{
- return i2c_ibuf(a->data, a->length, a->type & V_ASN1_NEG, pp);
+ unsigned char *ptr = pp != NULL ? *pp : NULL;
+ size_t ret = i2c_ibuf(a->data, a->length, a->type & V_ASN1_NEG, &ptr);
+
+ if (ret > INT_MAX) {
+ ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
+ return 0;
+ }
+ if (pp != NULL)
+ *pp = ptr;
+ return (int)ret;
}
/* Convert big endian buffer into uint64_t, return 0 on error */
} else
ret = *a;
- if (ASN1_STRING_set(ret, NULL, r) == 0) {
+ if (r > INT_MAX || ASN1_STRING_set(ret, NULL, (int)r) == 0) {
ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto err;
}
off = asn1_put_uint64(tbuf, r);
a->type &= ~V_ASN1_NEG;
}
- return ASN1_STRING_set(a, tbuf + off, sizeof(tbuf) - off);
+ return ASN1_STRING_set(a, tbuf + off, (int)(sizeof(tbuf) - off));
}
static int asn1_string_get_uint64(uint64_t *pr, const ASN1_STRING *a,
a->type = itype;
off = asn1_put_uint64(tbuf, r);
- return ASN1_STRING_set(a, tbuf + off, sizeof(tbuf) - off);
+ return ASN1_STRING_set(a, tbuf + off, (int)(sizeof(tbuf) - off));
}
/*
size_t off;
off = asn1_put_uint64(buf, r);
- return i2c_ibuf(buf + off, sizeof(buf) - off, neg, &p);
+ return (int)i2c_ibuf(buf + off, sizeof(buf) - off, neg, &p);
}
unsigned char *p;
int nchar;
int (*cpyfunc) (unsigned long, void *) = NULL;
- if (len == -1)
- len = strlen((const char *)in);
+ if (len == -1) {
+ size_t len_s = strlen((const char *)in);
+
+ if (len_s >= INT_MAX) {
+ ERR_raise(ERR_LIB_ASN1, ASN1_R_STRING_TOO_LONG);
+ return -1;
+ }
+ len = (int)len_s;
+ }
if (!mask)
mask = DIRSTRING_TYPE;
- if (len < 0)
+ if (len < 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_PASSED_INVALID_ARGUMENT);
return -1;
+ }
/* First do a string check and work out the number of characters */
switch (inform) {
unsigned long l;
BIGNUM *bl = NULL;
- if (num == 0)
+ if (num == 0) {
return 0;
- else if (num == -1)
- num = strlen(buf);
+ } else if (num == -1) {
+ size_t num_s = strlen(buf);
+
+ if (num_s >= INT_MAX) {
+ ERR_raise(ERR_LIB_ASN1, ASN1_R_LENGTH_TOO_LONG);
+ goto err;
+ }
+ num = (int)num_s;
+ }
p = buf;
c = *(p++);
return V_ASN1_PRINTABLESTRING;
if (len < 0)
- len = strlen((const char *)s);
+ len = (int)strlen((const char *)s);
while (len-- > 0) {
c = *(s++);
if (algor1 != NULL) {
const unsigned char *pp = aid;
- if (d2i_X509_ALGOR(&algor1, &pp, aid_len) == NULL) {
+ if (d2i_X509_ALGOR(&algor1, &pp, (long)aid_len) == NULL) {
ERR_raise(ERR_LIB_ASN1, ERR_R_INTERNAL_ERROR);
goto err;
}
if (algor2 != NULL) {
const unsigned char *pp = aid;
- if (d2i_X509_ALGOR(&algor2, &pp, aid_len) == NULL) {
+ if (d2i_X509_ALGOR(&algor2, &pp, (long)aid_len) == NULL) {
ERR_raise(ERR_LIB_ASN1, ERR_R_INTERNAL_ERROR);
goto err;
}
ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
goto err;
}
- ASN1_STRING_set0(signature, buf_out, outl);
+ ASN1_STRING_set0(signature, buf_out, (int)outl);
buf_out = NULL;
/*
* In the interests of compatibility, I'll make sure that the bit string
err:
OPENSSL_clear_free((char *)buf_in, inl);
OPENSSL_clear_free((char *)buf_out, outll);
- return outl;
+ return (int)outl;
}
objbuf = "";
}
}
- objlen = strlen(objbuf);
+ objlen = (int)strlen(objbuf);
if (!io_ch(arg, objbuf, objlen))
return -1;
if ((objlen < fld_len) && (flags & XN_FLAG_FN_ALIGN)) {
{
char* p;
ASN1_TIME *tmps = NULL;
- const size_t len = 20;
+ const int len = 20;
if (type == V_ASN1_UNDEF) {
if (is_utc(ts->tm_year))
ASN1_TIME t;
struct tm tm;
int rv = 0;
+ size_t len;
- t.length = strlen(str);
+ if ((len = strlen(str)) >= INT_MAX)
+ goto out;
+ t.length = (int)len;
t.data = (unsigned char *)str;
t.flags = ASN1_STRING_FLAG_X509_TIME;
int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str)
{
ASN1_UTCTIME t;
+ size_t len;
+ if ((len = strlen(str)) >= INT_MAX)
+ return 0;
t.type = V_ASN1_UTCTIME;
- t.length = strlen(str);
+ t.length = (int)len;
t.data = (unsigned char *)str;
t.flags = 0;
const EVP_PKEY_ASN1_METHOD *ameth = NULL;
if (len == -1)
- len = strlen(str);
+ len = (int)strlen(str);
if (pe) {
#ifndef OPENSSL_NO_ENGINE
ENGINE *e;
if (r & 0x80)
goto err;
/* Update copy length */
- cpy_len -= cpy_start - orig_der;
+ cpy_len -= (int)(cpy_start - orig_der);
/*
* For IMPLICIT tagging the length should match the original length
* and constructed flag should be consistent.
/* Look for the ':' in name value pairs */
if (*p == ':') {
vstart = p + 1;
- vlen = len - (vstart - elem);
- len = p - elem;
+ vlen = len - (int)(vstart - elem);
+ len = (int)(p - elem);
break;
}
}
*ptag = tag_num;
/* If we have non numeric characters, parse them */
if (eptr)
- vlen -= eptr - vstart;
+ vlen -= (int)(eptr - vstart);
else
vlen = 0;
if (vlen) {
};
if (len == -1)
- len = strlen(tagstr);
+ len = (int)strlen(tagstr);
tntmp = tnst;
for (i = 0; i < OSSL_NELEM(tnst); i++, tntmp++) {
return 0;
}
}
- str->length = len;
+ str->length = (int)len;
if (data != NULL) {
memcpy(str->data, data, len);
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
void ossl_asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
int ossl_asn1_enc_restore(int *len, unsigned char **out, const ASN1_VALUE **pval,
const ASN1_ITEM *it);
-int ossl_asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen,
+int ossl_asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, long inlen,
const ASN1_ITEM *it);
void ossl_asn1_item_embed_free(ASN1_VALUE **pval, const ASN1_ITEM *it, int embed);
BIO_puts(bp, "Error in encoding\n");
goto end;
}
- hl = (p - op);
+ hl = (int)(p - op);
length -= hl;
/*
* if j == 0x21 it is a constructed indefinite length object
if ((j == 0x21) && (len == 0)) {
for (;;) {
r = asn1_parse2(bp, &p, (long)(tot - p),
- offset + (p - *pp), depth + 1,
+ offset + (int)(p - *pp), depth + 1,
indent, dump);
if (r == 0)
goto end;
if ((r == 2) || (p >= tot)) {
- len = p - sp;
+ len = (long)(p - sp);
break;
}
}
while (p < ep) {
sp = p;
r = asn1_parse2(bp, &p, tmp,
- offset + (p - *pp), depth + 1,
+ offset + (int)(p - *pp), depth + 1,
indent, dump);
if (r == 0)
goto end;
- tmp -= p - sp;
+ tmp -= (long)(p - sp);
}
}
} else if (xclass != 0) {
{
char linebuf[MAX_SMLEN];
int len, blen;
+ size_t blen_s = strlen(bound);
int eol = 0, next_eol = 0;
BIO *bpart = NULL;
STACK_OF(BIO) *parts;
char state, part, first;
- blen = strlen(bound);
+ if (blen_s > MAX_SMLEN)
+ return 0;
+ blen = (int)blen_s;
part = 0;
state = 0;
first = 1;
*/
static int mime_bound_check(char *line, int linelen, const char *bound, int blen)
{
- if (linelen == -1)
- linelen = strlen(line);
- if (blen == -1)
- blen = strlen(bound);
+ if (linelen < 0 || blen < 0)
+ return 0;
/* Quickly eliminate if line length too short */
if (blen + 2 > linelen)
return 0;
static int asn1_bio_puts(BIO *b, const char *str)
{
- return asn1_bio_write(b, str, strlen(str));
+ size_t len = strlen(str);
+
+ if (len > INT_MAX)
+ return -1;
+
+ return asn1_bio_write(b, str, (int)len);
}
static int asn1_bio_gets(BIO *b, char *str, int size)
if (*ndef_aux->boundary == NULL)
return 0;
- *plen = *ndef_aux->boundary - *pbuf;
+ *plen = (int)(*ndef_aux->boundary - *pbuf);
return 1;
}
if (*ndef_aux->boundary == NULL)
return 0;
*pbuf = *ndef_aux->boundary;
- *plen = derlen - (*ndef_aux->boundary - ndef_aux->derbuf);
+ *plen = derlen - (int)(*ndef_aux->boundary - ndef_aux->derbuf);
return 1;
}
/* This is just a probe. It might fail, so we ignore errors */
ERR_set_mark();
- p8info = d2i_PKCS8_PRIV_KEY_INFO(NULL, pp, len);
+ p8info = d2i_PKCS8_PRIV_KEY_INFO(NULL, pp, length);
ERR_pop_to_mark();
if (p8info != NULL) {
int64_t v;
IMPLEMENT_ASN1_FUNCTIONS(SCRYPT_PARAMS)
-static X509_ALGOR *pkcs5_scrypt_set(const unsigned char *salt, size_t saltlen,
+static X509_ALGOR *pkcs5_scrypt_set(const unsigned char *salt, int saltlen,
size_t keylen, uint64_t N, uint64_t r,
uint64_t p);
return NULL;
}
-static X509_ALGOR *pkcs5_scrypt_set(const unsigned char *salt, size_t saltlen,
+static X509_ALGOR *pkcs5_scrypt_set(const unsigned char *salt, int saltlen,
size_t keylen, uint64_t N, uint64_t r,
uint64_t p)
{
} else if (ret == -1)
return -1;
if (aux && (aux->flags & ASN1_AFLG_BROKEN)) {
- len = tmplen - (p - *in);
+ len = tmplen - (long)(p - *in);
seq_nolen = 1;
}
/* If indefinite we don't do a length check */
ERR_raise(ERR_LIB_ASN1, ASN1_R_UNEXPECTED_EOC);
goto err;
}
- len -= p - q;
+ len -= (long)(p - q);
seq_eoc = 0;
break;
}
continue;
}
/* Update length */
- len -= p - q;
+ len -= (long)(p - q);
}
/* Check for EOC if expecting one */
}
}
/* Save encoding */
- if (!ossl_asn1_enc_save(pval, *in, p - *in, it))
+ if (!ossl_asn1_enc_save(pval, *in, (long)(p - *in), it))
goto auxerr;
if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL))
goto auxerr;
return 0;
}
/* We read the field in OK so update length */
- len -= p - q;
+ len -= (long)(p - q);
if (exp_eoc) {
/* If NDEF we must have an EOC here */
if (!asn1_check_eoc(&p, len)) {
ERR_raise(ERR_LIB_ASN1, ASN1_R_UNEXPECTED_EOC);
goto err;
}
- len -= p - q;
+ len -= (long)(p - q);
sk_eoc = 0;
break;
}
ASN1_item_free(skfield, ASN1_ITEM_ptr(tt->item));
goto err;
}
- len -= p - q;
+ len -= (long)(p - q);
if (!sk_ASN1_VALUE_push((STACK_OF(ASN1_VALUE) *)*val, skfield)) {
ERR_raise(ERR_LIB_ASN1, ERR_R_CRYPTO_LIB);
ASN1_item_free(skfield, ASN1_ITEM_ptr(tt->item));
if (inf) {
if (!asn1_find_end(&p, plen, inf))
goto err;
- len = p - cont;
+ len = (long)(p - cont);
} else {
- len = p - cont + plen;
+ len = (long)(p - cont) + plen;
p += plen;
}
} else if (cst) {
if (!asn1_collect(&buf, &p, plen, inf, -1, V_ASN1_UNIVERSAL, 0)) {
goto err;
}
- len = buf.length;
+ len = (long)buf.length;
/* Append a final null to string */
if (!BUF_MEM_grow_clean(&buf, len + 1)) {
ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
} else {
p += plen;
}
- len -= p - q;
+ len -= (long)(p - q);
}
if (expected_eoc) {
ERR_raise(ERR_LIB_ASN1, ASN1_R_MISSING_EOC);
return 0;
} else if (plen && !collect_data(buf, &p, plen))
return 0;
- len -= p - q;
+ len -= (long)(p - q);
}
if (inf) {
ERR_raise(ERR_LIB_ASN1, ASN1_R_MISSING_EOC);
static int collect_data(BUF_MEM *buf, const unsigned char **p, long plen)
{
- int len;
+ long len;
if (buf) {
- len = buf->length;
+ len = (long)buf->length;
+ if (len + plen < 0) {
+ /* resulting buffer length will not fit into long */
+ ERR_raise(ERR_LIB_ASN1, ASN1_R_LENGTH_TOO_LONG);
+ return 0;
+ }
if (!BUF_MEM_grow_clean(buf, len + plen)) {
ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
return 0;
ctx->plen = plen;
ctx->pclass = pclass;
ctx->ptag = ptag;
- ctx->hdrlen = p - q;
+ ctx->hdrlen = (int)(p - q);
ctx->valid = 1;
/*
* If definite length, and no error, length + header can't exceed
}
if ((i & 1) != 0)
- plen = len - (p - q);
+ plen = len - (long)(p - q);
if (inf != NULL)
*inf = i & 1;
}
}
-int ossl_asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen,
+int ossl_asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, long inlen,
const ASN1_ITEM *it)
{
ASN1_ENCODING *enc = asn1_get_enc_ptr(pval, it);
return 1;
OPENSSL_free(enc->enc);
- if (inlen <= 0)
+ if (inlen <= 0) {
+ enc->enc = NULL;
return 0;
+ }
if ((enc->enc = OPENSSL_malloc(inlen)) == NULL)
return 0;
memcpy(enc->enc, in, inlen);
async_pool *pool;
size_t curr_size = 0;
- if (init_size > max_size) {
+ if (init_size > max_size || max_size > INT_MAX) {
ERR_raise(ERR_LIB_ASYNC, ASYNC_R_INVALID_POOL_SIZE);
return 0;
}
if (pool == NULL)
return 0;
- pool->jobs = sk_ASYNC_JOB_new_reserve(NULL, init_size);
+ pool->jobs = sk_ASYNC_JOB_new_reserve(NULL, (int)init_size);
if (pool->jobs == NULL) {
ERR_raise(ERR_LIB_ASYNC, ERR_R_CRYPTO_LIB);
OPENSSL_free(pool);
static int buffer_puts(BIO *b, const char *str)
{
- return buffer_write(b, str, strlen(str));
+ size_t len = strlen(str);
+
+ if (len > INT_MAX)
+ return -1;
+ return buffer_write(b, str, (int)len);
}
while ((foundnl || p - in > ctx->obuf_size - ctx->obuf_len)
&& ctx->obuf_len > 0) {
int orig_olen = ctx->obuf_len;
+ int llen = (int)(p - in);
i = ctx->obuf_size - ctx->obuf_len;
- if (p - in > 0) {
- if (i >= p - in) {
- memcpy(&(ctx->obuf[ctx->obuf_len]), in, p - in);
- ctx->obuf_len += p - in;
- inl -= p - in;
- num += p - in;
+ if (llen > 0) {
+ if (i >= llen) {
+ memcpy(&(ctx->obuf[ctx->obuf_len]), in, llen);
+ ctx->obuf_len += llen;
+ inl -= llen;
+ num += llen;
in = p;
} else {
memcpy(&(ctx->obuf[ctx->obuf_len]), in, i);
* if a NL was found and there is anything to write.
*/
if ((foundnl || p - in > ctx->obuf_size) && p - in > 0) {
- i = BIO_write(b->next_bio, in, p - in);
+ i = BIO_write(b->next_bio, in, (int)(p - in));
if (i <= 0) {
BIO_copy_next_retry(b);
if (i < 0)
static int linebuffer_puts(BIO *b, const char *str)
{
- return linebuffer_write(b, str, strlen(str));
+ size_t len = strlen(str);
+
+ if (len > INT_MAX)
+ return -1;
+ return linebuffer_write(b, str, (int)len);
}
static int prefix_puts(BIO *b, const char *str)
{
- return BIO_write(b, str, strlen(str));
+ size_t len = strlen(str);
+
+ if (len > INT_MAX)
+ return -1;
+ return BIO_write(b, str, (int)len);
}
socklen_t BIO_ADDRINFO_sockaddr_size(const BIO_ADDRINFO *bai)
{
if (bai != NULL)
- return bai->bai_addrlen;
+ return (socklen_t)bai->bai_addrlen;
return 0;
}
b = (BIO *)bio->cb_arg;
if (b != NULL)
- BIO_write(b, buf, strlen(buf));
+ BIO_write(b, buf, (int)strlen(buf));
#if !defined(OPENSSL_NO_STDIO)
else
fputs(buf, stderr);
#ifndef OPENSSL_NO_STDIO
static int write_fp(const void *data, size_t len, void *fp)
{
- return UP_fwrite(data, len, 1, fp);
+ return (int)UP_fwrite(data, len, 1, fp);
}
int BIO_dump_fp(FILE *fp, const void *s, int len)
static int write_bio(const void *data, size_t len, void *bp)
{
- return BIO_write((BIO *)bp, (const char *)data, len);
+ if (len > INT_MAX)
+ return -1;
+ return BIO_write((BIO *)bp, (const char *)data, (int)len);
}
int BIO_dump(BIO *bp, const void *s, int len)
if (inret > 0 && (oper & BIO_CB_RETURN) && bareoper != BIO_CB_CTRL) {
if (*processed > INT_MAX)
return -1;
- inret = *processed;
+ inret = (long)*processed;
}
ret = b->callback(b, oper, argp, argi, argl, inret);
if (HAS_CALLBACK(b))
ret = (size_t)bio_call_callback(b, BIO_CB_SENDMMSG | BIO_CB_RETURN,
- (void *)&args, ret, 0, 0, ret, NULL);
+ (void *)&args, ret, 0, 0, (long)ret, NULL);
- return ret;
+ return ret > 0;
}
int BIO_recvmmsg(BIO *b, BIO_MSG *msg,
if (HAS_CALLBACK(b))
ret = (size_t)bio_call_callback(b, BIO_CB_RECVMMSG | BIO_CB_RETURN,
- (void *)&args, ret, 0, 0, ret, NULL);
+ (void *)&args, ret, 0, 0, (long)ret, NULL);
- return ret;
+ return ret > 0;
}
int BIO_get_rpoll_descriptor(BIO *b, BIO_POLL_DESCRIPTOR *desc)
if (*ptr++ == '\n')
break;
*ptr = '\0';
- return ret > 0 || BIO_eof(bio) ? ptr - buf : ret;
+ return ret > 0 || BIO_eof(bio) ? (int)(ptr - buf) : ret;
}
int BIO_indent(BIO *b, int indent, int max)
size_t currlen;
state = DP_S_DEFAULT;
- flags = currlen = cflags = min = 0;
+ currlen = 0;
+ flags = cflags = min = 0;
max = -1;
ch = *format++;
case 's':
strvalue = va_arg(args, char *);
if (max < 0) {
- if (buffer)
+ if (buffer || *maxlen > INT_MAX)
max = INT_MAX;
else
- max = *maxlen;
+ max = (int)*maxlen;
}
if (!fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,
flags, min, max))
case 'n':
{
int *num;
+
num = va_arg(args, int *);
- *num = currlen;
+ *num = (int)currlen;
}
break;
case '%':
strln = OPENSSL_strnlen(value, max < 0 ? SIZE_MAX : (size_t)max);
- padlen = min - strln;
+ padlen = (int)(min - strln);
if (min < 0 || padlen < 0)
padlen = 0;
if (max >= 0) {
zpadlen = max - place;
spadlen =
- min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - strlen(prefix);
+ min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - (int)strlen(prefix);
if (zpadlen < 0)
zpadlen = 0;
if (spadlen < 0)
static int acpt_puts(BIO *bp, const char *str)
{
- int n, ret;
+ int ret;
+ size_t n = strlen(str);
- n = strlen(str);
- ret = acpt_write(bp, str, n);
+ if (n > INT_MAX)
+ return -1;
+ ret = acpt_write(bp, str, (int)n);
return ret;
}
}
while (rest);
- return size;
+ return (int)size;
}
/*-
}
while (rest);
- return num;
+ return (int)num;
}
/*-
if (b->peer == NULL || b->closed)
ret = 0;
else
- ret = (long)b->size - b->len;
+ ret = (long)(b->size - b->len);
break;
case BIO_C_GET_READ_REQUEST:
static int bio_puts(BIO *bio, const char *str)
{
- return bio_write(bio, str, strlen(str));
+ size_t len = strlen(str);
+
+ if (len > INT_MAX)
+ return -1;
+ return bio_write(bio, str, (int)len);
}
static int bio_make_pair(BIO *bio1, BIO *bio2)
long r;
int ret = 0;
+ if (writebuf1 > LONG_MAX || writebuf2 > LONG_MAX)
+ goto err;
+
bio1 = BIO_new(BIO_s_bio());
if (bio1 == NULL)
goto err;
goto err;
if (writebuf1) {
- r = BIO_set_write_buf_size(bio1, writebuf1);
+ r = BIO_set_write_buf_size(bio1, (long)writebuf1);
if (!r)
goto err;
}
if (writebuf2) {
- r = BIO_set_write_buf_size(bio2, writebuf2);
+ r = BIO_set_write_buf_size(bio2, (long)writebuf2);
if (!r)
goto err;
}
static int conn_puts(BIO *bp, const char *str)
{
- int n, ret;
+ int ret;
+ size_t n = strlen(str);
- n = strlen(str);
- ret = conn_write(bp, str, n);
+ if (n > INT_MAX)
+ return -1;
+ ret = conn_write(bp, str, (int)n);
return ret;
}
break;
}
*ptr = '\0';
- return ret > 0 || (bio->flags & BIO_FLAGS_IN_EOF) != 0 ? ptr - buf : ret;
+ return ret > 0 || (bio->flags & BIO_FLAGS_IN_EOF) != 0 ? (int)(ptr - buf) : ret;
}
static int conn_sendmmsg(BIO *bio, BIO_MSG *msg, size_t stride, size_t num_msgs,
static int dgram_puts(BIO *bp, const char *str)
{
- int n, ret;
+ int ret;
+ size_t n = strlen(str);
- n = strlen(str);
- ret = dgram_write(bp, str, n);
+ if (n > INT_MAX)
+ return -1;
+ ret = dgram_write(bp, str, (int)n);
return ret;
}
{
struct bio_dgram_pair_st *b = bio->ptr;
- return b->mtu;
+ return (int)b->mtu;
}
/* BIO_dgram_set_mtu (BIO_CTRL_DGRAM_SET_MTU) */
long r;
BIO *bio1 = NULL, *bio2 = NULL;
+ if (writebuf1 > LONG_MAX || writebuf2 > LONG_MAX)
+ goto err;
+
bio1 = BIO_new(BIO_s_dgram_pair());
if (bio1 == NULL)
goto err;
goto err;
if (writebuf1 > 0) {
- r = BIO_set_write_buf_size(bio1, writebuf1);
+ r = BIO_set_write_buf_size(bio1, (long)writebuf1);
if (r == 0)
goto err;
}
if (writebuf2 > 0) {
- r = BIO_set_write_buf_size(bio2, writebuf2);
+ r = BIO_set_write_buf_size(bio2, (long)writebuf2);
if (r == 0)
goto err;
}
l = dgram_pair_read_actual(bio, buf, (size_t)sz_, NULL, NULL, 0);
if (l < 0) {
if (l != -BIO_R_NON_FATAL)
- ERR_raise(ERR_LIB_BIO, -l);
+ ERR_raise(ERR_LIB_BIO, (int)-l);
ret = -1;
} else {
ret = (int)l;
if (i > 0) {
ret = 1;
} else {
- ERR_raise(ERR_LIB_BIO, -l);
+ ERR_raise(ERR_LIB_BIO, (int)-l);
ret = 0;
}
goto out;
l = dgram_pair_read_actual(bio, buf, (size_t)sz_, NULL, NULL, 0);
if (l < 0) {
if (l != -BIO_R_NON_FATAL)
- ERR_raise(ERR_LIB_BIO, -l);
+ ERR_raise(ERR_LIB_BIO, (int)-l);
ret = -1;
} else {
ret = (int)l;
l = dgram_pair_write_actual(bio, buf, (size_t)sz_, NULL, NULL, 0);
if (l < 0) {
- ERR_raise(ERR_LIB_BIO, -l);
+ ERR_raise(ERR_LIB_BIO, (int)-l);
ret = -1;
} else {
ret = (int)l;
size_t stride, size_t num_msg,
uint64_t flags, size_t *num_processed)
{
- ossl_ssize_t ret, l;
+ ossl_ssize_t l;
BIO_MSG *m;
size_t i;
struct bio_dgram_pair_st *b = bio->ptr;
+ int ret = 0;
if (num_msg == 0) {
*num_processed = 0;
if (i > 0) {
ret = 1;
} else {
- ERR_raise(ERR_LIB_BIO, -l);
- ret = 0;
+ ERR_raise(ERR_LIB_BIO, (int)-l);
}
goto out;
}
if (out != NULL) {
clear_sys_error();
- ret = UP_read(b->num, out, outl);
+ ret = (int)UP_read(b->num, out, outl);
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (BIO_fd_should_retry(ret))
{
int ret;
clear_sys_error();
- ret = UP_write(b->num, in, inl);
+ ret = (int)UP_write(b->num, in, inl);
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (BIO_fd_should_retry(ret))
static int fd_puts(BIO *bp, const char *str)
{
- int n, ret;
+ int ret;
+ size_t n = strlen(str);
- n = strlen(str);
- ret = fd_write(bp, str, n);
+ if (n > INT_MAX)
+ return -1;
+ ret = fd_write(bp, str, (int)n);
return ret;
}
ptr[0] = '\0';
if (buf[0] != '\0')
- ret = strlen(buf);
+ ret = (int)strlen(buf);
return ret;
}
if (b->init && (out != NULL)) {
if (b->flags & BIO_FLAGS_UPLINK_INTERNAL)
- ret = UP_fread(out, 1, (int)outl, b->ptr);
+ ret = (int)UP_fread(out, 1, outl, b->ptr);
else
- ret = fread(out, 1, (int)outl, (FILE *)b->ptr);
+ ret = (int)fread(out, 1, outl, (FILE *)b->ptr);
if (ret == 0
&& (b->flags & BIO_FLAGS_UPLINK_INTERNAL
? UP_ferror((FILE *)b->ptr) : ferror((FILE *)b->ptr))) {
if (b->init && (in != NULL)) {
if (b->flags & BIO_FLAGS_UPLINK_INTERNAL)
- ret = UP_fwrite(in, (int)inl, 1, b->ptr);
+ ret = (int)UP_fwrite(in, inl, 1, b->ptr);
else
- ret = fwrite(in, (int)inl, 1, (FILE *)b->ptr);
+ ret = (int)fwrite(in, inl, 1, (FILE *)b->ptr);
if (ret)
ret = inl;
/* ret=fwrite(in,1,(int)inl,(FILE *)b->ptr); */
goto err;
}
if (buf[0] != '\0')
- ret = strlen(buf);
+ ret = (int)strlen(buf);
err:
return ret;
}
static int file_puts(BIO *bp, const char *str)
{
- int n, ret;
+ int ret;
+ size_t n = strlen(str);
- n = strlen(str);
- ret = file_write(bp, str, n);
+ if (n > INT_MAX)
+ return -1;
+ ret = file_write(bp, str, (int)n);
return ret;
}
static int mem_write(BIO *b, const char *in, int inl)
{
int ret = -1;
- int blen;
+ size_t blen;
BIO_BUF_MEM *bbm = (BIO_BUF_MEM *)b->ptr;
if (b->flags & BIO_FLAGS_MEM_RDONLY) {
char **pptr;
BIO_BUF_MEM *bbm = (BIO_BUF_MEM *)b->ptr;
BUF_MEM *bm, *bo; /* bio_mem, bio_other */
- long off, remain;
+ ossl_ssize_t off, remain;
if (b->flags & BIO_FLAGS_MEM_RDONLY) {
bm = bbm->buf;
bm->data = (num != 0) ? bo->data + num : bo->data;
bm->length = bo->length - num;
bm->max = bo->max - num;
- off = num;
+ off = (ossl_ssize_t)num;
/* FALLTHRU */
case BIO_C_FILE_TELL:
- ret = off;
+ ret = (long)off;
+ if (off > LONG_MAX)
+ ret = -1;
break;
case BIO_CTRL_EOF:
ret = (long)(bm->length == 0);
if (bp->flags & BIO_FLAGS_MEM_RDONLY)
bm = bbm->buf;
BIO_clear_retry_flags(bp);
- j = bm->length;
+ j = bm->length < INT_MAX ? (int)bm->length: INT_MAX;
if ((size - 1) < j)
j = size - 1;
if (j <= 0) {
static int mem_puts(BIO *bp, const char *str)
{
- int n, ret;
+ int ret;
+ size_t n = strlen(str);
- n = strlen(str);
- ret = mem_write(bp, str, n);
+ if (n > INT_MAX)
+ return -1;
+ ret = mem_write(bp, str, (int)n);
/* memory semantics is that it will always work */
return ret;
}
static int null_puts(BIO *bp, const char *str)
{
+ size_t n;
+
if (str == NULL)
return 0;
- return strlen(str);
+ n = strlen(str);
+ if (n > INT_MAX)
+ return -1;
+ return (int)n;
}
static int sock_puts(BIO *bp, const char *str)
{
- int n, ret;
+ int ret;
+ size_t n = strlen(str);
- n = strlen(str);
- ret = sock_write(bp, str, n);
+ if (n > INT_MAX)
+ return -1;
+ ret = sock_write(bp, str, (int)n);
return ret;
}
carry &= (t2 == 0);
}
*rp = carry;
- r->top += carry;
+ r->top += (int)carry;
r->neg = 0;
bn_check_top(r);
}
mask = (BN_ULONG)0 - ((rtop - ntop) >> (8 * sizeof(ntop) - 1));
/* always true, if (rtop >= ntop) n->top = r->top; */
- n->top = (int)(rtop & ~mask) | (ntop & mask);
+ n->top = (int)((rtop & ~mask) | (ntop & mask));
n->flags |= (BN_FLG_FIXED_TOP & ~mask);
}
ret = bn_mul_mont_fixed_top(n, n, r, b->m_ctx, ctx);
pow2_numbits_temp = r->d[i] | g->d[i];
pow2_condition_mask = constant_time_is_zero_bn(pow2_flag);
pow2_flag &= constant_time_is_zero_bn(pow2_numbits_temp);
- pow2_shifts += pow2_flag;
+ pow2_shifts += (int)pow2_flag;
pow2_numbits = constant_time_select_bn(pow2_condition_mask,
pow2_numbits, pow2_numbits_temp);
}
pow2_flag = 1;
for (j = 0; j < BN_BITS2; j++) {
pow2_flag &= pow2_numbits;
- pow2_shifts += pow2_flag;
+ pow2_shifts += (int)pow2_flag;
pow2_numbits >>= 1;
}
r[j++] = sign * digit;
window_val >>= 1;
- window_val += bit * BN_is_bit_set(scalar, j + w);
+ window_val += bit * BN_is_bit_set(scalar, (int)(j + w));
if (window_val > next_bit) {
ERR_raise(ERR_LIB_BN, ERR_R_INTERNAL_ERROR);
int res = 0;
for (i = 0; i < b->top; i++) {
- res = constant_time_select_int(constant_time_lt_bn(ap[i], bp[i]),
+ res = constant_time_select_int((int)constant_time_lt_bn(ap[i], bp[i]),
-1, res);
- res = constant_time_select_int(constant_time_lt_bn(bp[i], ap[i]),
+ res = constant_time_select_int((int)constant_time_lt_bn(bp[i], ap[i]),
1, res);
}
return res;
if (a->neg || a->top == 0)
return 0;
- res = constant_time_select_int(constant_time_eq_bn(ap[0], w), 1, 0);
+ res = constant_time_select_int((int)constant_time_eq_bn(ap[0], w), 1, 0);
for (i = 1; i < a->top; i++)
- res = constant_time_select_int(constant_time_is_zero_bn(ap[i]),
+ res = constant_time_select_int((int)constant_time_is_zero_bn(ap[i]),
res, 0);
return res;
}
BN_ULONG carry, temp, mask, *rp, *tp = storage;
const BN_ULONG *ap, *bp;
- if (bn_wexpand(r, mtop) == NULL)
+ if (bn_wexpand(r, (int)mtop) == NULL)
return 0;
if (mtop > OSSL_NELEM(storage)) {
bi += (i - b->dmax) >> (8 * sizeof(i) - 1);
}
rp = r->d;
- carry -= bn_sub_words(rp, tp, m->d, mtop);
+ carry -= bn_sub_words(rp, tp, m->d, (int)mtop);
for (i = 0; i < mtop; i++) {
rp[i] = (carry & tp[i]) | (~carry & rp[i]);
((volatile BN_ULONG *)tp)[i] = 0;
}
- r->top = mtop;
+ r->top = (int)mtop;
r->flags |= BN_FLG_FIXED_TOP;
r->neg = 0;
BN_ULONG borrow, carry, ta, tb, mask, *rp;
const BN_ULONG *ap, *bp;
- if (bn_wexpand(r, mtop) == NULL)
+ if (bn_wexpand(r, (int)mtop) == NULL)
return 0;
rp = r->d;
carry += (rp[i] < ta);
}
- r->top = mtop;
+ r->top = (int)mtop;
r->flags |= BN_FLG_FIXED_TOP;
r->neg = 0;
}
int ossl_bn_mont_ctx_set(BN_MONT_CTX *ctx, const BIGNUM *modulus, int ri, const unsigned char *rr,
- size_t rrlen, uint32_t nlo, uint32_t nhi)
+ int rrlen, uint32_t nlo, uint32_t nhi)
{
if (BN_copy(&ctx->N, modulus) == NULL)
return 0;
c = t >> (BN_BITS2 - 1);
}
*rp = c;
- r->top += c;
+ r->top += (int)c;
bn_check_top(r);
return 1;
}
const BN_ULONG *m,
BN_ULONG *tmp, size_t num)
{
- carry -= bn_sub_words(tmp, r, m, num);
+ carry -= bn_sub_words(tmp, r, m, (int)num);
bn_select_words(r, carry, r /* tmp < 0 */, tmp /* tmp >= 0 */, num);
return carry;
}
ctx->nlast_block = -1;
if (EVP_CIPHER_CTX_get0_cipher(ctx->cctx) == NULL)
return 0;
- if (EVP_CIPHER_CTX_set_key_length(ctx->cctx, keylen) <= 0)
+ if (keylen > INT_MAX
+ || EVP_CIPHER_CTX_set_key_length(ctx->cctx, (int)keylen) <= 0)
return 0;
if (!EVP_EncryptInit_ex2(ctx->cctx, NULL, key, zero_iv, param))
return 0;
nleft = dlen;
memcpy(ctx->last_block + ctx->nlast_block, data, nleft);
dlen -= nleft;
- ctx->nlast_block += nleft;
+ ctx->nlast_block += (int)nleft;
/* If no more to process return */
if (dlen == 0)
return 1;
}
} else {
while (cipher_blocks > max_burst_blocks) {
- if (EVP_Cipher(ctx->cctx, buf, data, max_burst_blocks * bl) <= 0)
+ if (EVP_Cipher(ctx->cctx, buf, data, (int)(max_burst_blocks * bl)) <= 0)
return 0;
dlen -= max_burst_blocks * bl;
data += max_burst_blocks * bl;
cipher_blocks -= max_burst_blocks;
}
if (cipher_blocks > 0) {
- if (EVP_Cipher(ctx->cctx, buf, data, cipher_blocks * bl) <= 0)
+ if (EVP_Cipher(ctx->cctx, buf, data, (int)(cipher_blocks * bl)) <= 0)
return 0;
dlen -= cipher_blocks * bl;
data += cipher_blocks * bl;
}
/* Copy any data left to last block buffer */
memcpy(ctx->last_block, data, dlen);
- ctx->nlast_block = dlen;
+ ctx->nlast_block = (int)dlen;
return 1;
}
return itav;
}
- if (OBJ_obj2txt(name + offset, sizeof(name) - offset, obj, 0) < 0)
+ if (OBJ_obj2txt(name + offset, (int)(sizeof(name) - offset), obj, 0) < 0)
strcat(name, "<unknown>");
ossl_cmp_log2(WARN, ctx, "%s' while expecting 'id-it-%s'", name, desc);
OSSL_CMP_ITAV_free(itav);
}
/* assign to *tgt a random byte array of given length */
-static int set_random(ASN1_OCTET_STRING **tgt, OSSL_CMP_CTX *ctx, size_t len)
+static int set_random(ASN1_OCTET_STRING **tgt, OSSL_CMP_CTX *ctx, int len)
{
unsigned char *bytes = OPENSSL_malloc(len);
int res = 0;
&protection, &sig_len))
goto end;
- if ((prot = ASN1_BIT_STRING_new()) == NULL)
+ if (sig_len > INT_MAX || (prot = ASN1_BIT_STRING_new()) == NULL)
goto end;
/* OpenSSL by default encodes all bit strings as ASN.1 NamedBitList */
ossl_asn1_string_set_bits_left(prot, 0);
- if (!ASN1_BIT_STRING_set(prot, protection, sig_len)) {
+ if (!ASN1_BIT_STRING_set(prot, protection, (int)sig_len)) {
ASN1_BIT_STRING_free(prot);
prot = NULL;
}
if (HAS_PREFIX(level, OSSL_CMP_LOG_PREFIX))
level += strlen(OSSL_CMP_LOG_PREFIX);
- len = end_level - level;
+ len = (int)(end_level - level);
if (len > max_level_len)
return -1;
OPENSSL_strlcpy(level_copy, level, len + 1);
ASN1_OCTET_STRING *ukm;
const unsigned char *p;
unsigned char *dukm = NULL;
- size_t dukmlen = 0;
+ int dukmlen = 0;
int keylen, plen;
EVP_CIPHER *kekcipher = NULL;
EVP_CIPHER_CTX *kekctx;
ASN1_OCTET_STRING *ukm;
unsigned char *penc = NULL, *dukm = NULL;
int penclen;
- size_t dukmlen = 0;
+ int dukmlen = 0;
int rv = 0;
int kdf_type, wrap_nid;
const EVP_MD *kdf_md;
piv = aparams.iv;
if (ec->taglen > 0
&& EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
- ec->taglen, ec->tag) <= 0) {
+ (int)ec->taglen, ec->tag) <= 0) {
ERR_raise(ERR_LIB_CMS, CMS_R_CIPHER_AEAD_SET_TAG_ERROR);
goto err;
}
if (ec->keylen != tkeylen) {
/* If necessary set key length */
- if (EVP_CIPHER_CTX_set_key_length(ctx, ec->keylen) <= 0) {
+ if (EVP_CIPHER_CTX_set_key_length(ctx, (int)ec->keylen) <= 0) {
/*
* Only reveal failure if debugging so we don't leak information
* which may be useful in MMA.
if (EVP_PKEY_encrypt(pctx, ek, &eklen, ec->key, ec->keylen) <= 0)
goto err;
- ASN1_STRING_set0(ktri->encryptedKey, ek, eklen);
+ ASN1_STRING_set0(ktri->encryptedKey, ek, (int)eklen);
ek = NULL;
ret = 1;
CMS_KEKRecipientInfo *kekri;
STACK_OF(CMS_RecipientInfo) *ris = CMS_get0_RecipientInfos(cms);
- if (ris == NULL)
+ if (ris == NULL || idlen > INT_MAX)
goto err;
if (nid == NID_undef) {
kekri->key = key;
kekri->keylen = keylen;
- ASN1_STRING_set0(kekri->kekid->keyIdentifier, id, idlen);
+ ASN1_STRING_set0(kekri->kekid->keyIdentifier, id, (int)idlen);
kekri->kekid->date = date;
EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
if (!EVP_EncryptInit_ex(ctx, cipher, NULL, kekri->key, NULL)
- || !EVP_EncryptUpdate(ctx, wkey, &wkeylen, ec->key, ec->keylen)
+ || !EVP_EncryptUpdate(ctx, wkey, &wkeylen, ec->key, (int)ec->keylen)
|| !EVP_EncryptFinal_ex(ctx, wkey + wkeylen, &outlen)) {
ERR_raise(ERR_LIB_CMS, CMS_R_WRAP_ERROR);
goto err;
int outlen;
keklen = EVP_CIPHER_CTX_get_key_length(kari->ctx);
- if (keklen > EVP_MAX_KEY_LENGTH)
+ if (keklen > EVP_MAX_KEY_LENGTH || inlen > INT_MAX)
return 0;
/* Derive KEK */
if (EVP_PKEY_derive(kari->pctx, kek, &keklen) <= 0)
if (!EVP_CipherInit_ex(kari->ctx, NULL, NULL, kek, NULL, enc))
goto err;
/* obtain output length of ciphered key */
- if (!EVP_CipherUpdate(kari->ctx, NULL, &outlen, in, inlen))
+ if (!EVP_CipherUpdate(kari->ctx, NULL, &outlen, in, (int)inlen))
goto err;
out = OPENSSL_malloc(outlen);
if (out == NULL)
goto err;
- if (!EVP_CipherUpdate(kari->ctx, out, &outlen, in, inlen))
+ if (!EVP_CipherUpdate(kari->ctx, out, &outlen, in, (int)inlen))
goto err;
*pout = out;
*poutlen = (size_t)outlen;
if (!cms_kek_cipher(&enckey, &enckeylen, ec->key, ec->keylen,
kari, 1))
return 0;
- ASN1_STRING_set0(rek->encryptedKey, enckey, enckeylen);
+ ASN1_STRING_set0(rek->encryptedKey, enckey, (int)enckeylen);
}
return 1;
const unsigned char *in, size_t inlen,
EVP_CIPHER_CTX *ctx)
{
- size_t blocklen = EVP_CIPHER_CTX_get_block_size(ctx);
+ int blocklen = EVP_CIPHER_CTX_get_block_size(ctx);
unsigned char *tmp;
int outl, rv = 0;
- if (blocklen == 0)
+ if (blocklen <= 0)
return 0;
- if (inlen < 2 * blocklen) {
+ if (inlen < 2 * (size_t)blocklen) {
/* too small */
return 0;
}
- if (inlen % blocklen) {
+ if (inlen > INT_MAX || inlen % blocklen) {
/* Invalid size */
return 0;
}
|| !EVP_DecryptUpdate(ctx, tmp, &outl,
tmp + inlen - blocklen, blocklen)
/* Can now decrypt first n - 1 blocks */
- || !EVP_DecryptUpdate(ctx, tmp, &outl, in, inlen - blocklen)
+ || !EVP_DecryptUpdate(ctx, tmp, &outl, in, (int)(inlen - blocklen))
/* Reset IV to original value */
|| !EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, NULL)
/* Decrypt again */
- || !EVP_DecryptUpdate(ctx, tmp, &outl, tmp, inlen))
+ || !EVP_DecryptUpdate(ctx, tmp, &outl, tmp, (int)inlen))
goto err;
/* Check check bytes */
if (((tmp[1] ^ tmp[4]) & (tmp[2] ^ tmp[5]) & (tmp[3] ^ tmp[6])) != 0xff) {
olen - 4 - inlen, 0) <= 0)
return 0;
/* Encrypt twice */
- if (!EVP_EncryptUpdate(ctx, out, &dummy, out, olen)
- || !EVP_EncryptUpdate(ctx, out, &dummy, out, olen))
+ if (!EVP_EncryptUpdate(ctx, out, &dummy, out, (int)olen)
+ || !EVP_EncryptUpdate(ctx, out, &dummy, out, (int)olen))
return 0;
}
/* Finish password based key derivation to setup key in "ctx" */
if (EVP_PBE_CipherInit_ex(algtmp->algorithm,
- (char *)pwri->pass, pwri->passlen,
+ (char *)pwri->pass, (int)pwri->passlen,
algtmp->parameter, kekctx, en_de,
cms_ctx->libctx, cms_ctx->propq) < 0) {
ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB);
if (!kek_wrap_key(key, &keylen, ec->key, ec->keylen, kekctx, cms_ctx))
goto err;
pwri->encryptedKey->data = key;
- pwri->encryptedKey->length = keylen;
+ pwri->encryptedKey->length = (int)keylen;
} else {
key = OPENSSL_malloc(pwri->encryptedKey->length);
if (key == NULL)
return 0;
if ((aid_len = params[0].return_size) == 0)
return 0;
- if (d2i_X509_ALGOR(&alg, &pp, aid_len) == NULL)
+ if (d2i_X509_ALGOR(&alg, &pp, (long)aid_len) == NULL)
return 0;
return 1;
}
OPENSSL_free(sig);
goto err;
}
- ASN1_STRING_set0(si->signature, sig, siglen);
+ ASN1_STRING_set0(si->signature, sig, (int)siglen);
} else {
unsigned char *sig;
unsigned int siglen;
EVP_MD_CTX_reset(mctx);
- ASN1_STRING_set0(si->signature, abuf, siglen);
+ ASN1_STRING_set0(si->signature, abuf, (int)siglen);
return 1;
* No data in input buffer try to read some in, if an error then
* return the total data read.
*/
- ret = BIO_read(next, ctx->decode.buf, ctx->decode.bufsize);
+ ret = BIO_read(next, ctx->decode.buf, (int)ctx->decode.bufsize);
if (ret <= 0) {
/* Total data read */
- int tot = outl - ctx->decode.avail_out;
+ int tot = outl - (int)ctx->decode.avail_out;
BIO_copy_next_retry(b);
if (ret < 0)
for (;;) {
/* If data in output buffer write it first */
while (ctx->encode.count > 0) {
- ret = BIO_write(next, ctx->encode.ptr, ctx->encode.count);
+ ret = BIO_write(next, ctx->encode.ptr, (int)ctx->encode.count);
if (ret <= 0) {
/* Total data written */
- int tot = inl - ctx->encode.avail_in;
+ int tot = inl - (int)ctx->encode.avail_in;
BIO_copy_next_retry(b);
if (ret < 0)
for (;;) {
/* If data in output buffer write it first */
while (ctx->encode.count > 0) {
- ret = BIO_write(next, ctx->encode.ptr, ctx->encode.count);
+ ret = BIO_write(next, ctx->encode.ptr, (int)ctx->encode.count);
if (ret <= 0) {
BIO_copy_next_retry(b);
return ret;
}
/* No more output space */
if (outBuf.pos == outBuf.size)
- return outBuf.pos;
+ return (int)outBuf.pos;
} while (ctx->decompress.inbuf.pos < ctx->decompress.inbuf.size);
/*
* No data in input buffer try to read some in, if an error then
* return the total data read.
*/
- ret = BIO_read(next, ctx->decompress.buffer, ctx->decompress.bufsize);
+ ret = BIO_read(next, ctx->decompress.buffer, (int)ctx->decompress.bufsize);
if (ret <= 0) {
BIO_copy_next_retry(b);
if (ret < 0 && outBuf.pos == 0)
return ret;
- return outBuf.pos;
+ return (int)outBuf.pos;
}
ctx->decompress.inbuf.size = ret;
ctx->decompress.inbuf.pos = 0;
/* If data in output buffer write it first */
while (ctx->compress.write_pos < ctx->compress.outbuf.pos) {
ret = BIO_write(next, (unsigned char*)ctx->compress.outbuf.dst + ctx->compress.write_pos,
- ctx->compress.outbuf.pos - ctx->compress.write_pos);
+ (int)(ctx->compress.outbuf.pos - ctx->compress.write_pos));
if (ret <= 0) {
BIO_copy_next_retry(b);
if (ret < 0 && inBuf.pos == 0)
return ret;
- return inBuf.pos;
+ return (int)inBuf.pos;
}
ctx->compress.write_pos += ret;
}
/* Have we consumed all supplied data? */
if (done)
- return inBuf.pos;
+ return (int)inBuf.pos;
/* Reset buffer */
ctx->compress.outbuf.pos = 0;
/* If data in output buffer write it first */
while (ctx->compress.write_pos < ctx->compress.outbuf.pos) {
ret = BIO_write(next, (unsigned char*)ctx->compress.outbuf.dst + ctx->compress.write_pos,
- ctx->compress.outbuf.pos - ctx->compress.write_pos);
+ (int)(ctx->compress.outbuf.pos - ctx->compress.write_pos));
if (ret <= 0) {
BIO_copy_next_retry(b);
return ret;
if (ctx->meth->compress == NULL) {
return -1;
}
- ret = ctx->meth->compress(ctx, out, olen, in, ilen);
+ ret = (int)ctx->meth->compress(ctx, out, olen, in, ilen);
if (ret > 0) {
ctx->compress_in += ilen;
ctx->compress_out += ret;
if (ctx->meth->expand == NULL) {
return -1;
}
- ret = ctx->meth->expand(ctx, out, olen, in, ilen);
+ ret = (int)ctx->meth->expand(ctx, out, olen, in, ilen);
if (ret > 0) {
ctx->expand_in += ilen;
ctx->expand_out += ret;
goto err;
if ((v = OPENSSL_malloc(sizeof(*v))) == NULL)
goto err;
- i = strlen(section) + 1;
+ i = (int)strlen(section) + 1;
if ((v->section = OPENSSL_malloc(i)) == NULL)
goto err;
if (in != NULL && BIO_gets(in, p, CONFBUFSIZE - 1) < 0)
goto err;
p[CONFBUFSIZE - 1] = '\0';
- ii = i = strlen(p);
+ ii = i = (int)strlen(p);
if (first_call) {
/* Other BOMs imply unsupported multibyte encoding,
* so don't strip them and let the error raise */
static int str_copy(CONF *conf, char *section, char **pto, char *from)
{
- int q, r, rr = 0, to = 0, len = 0;
+ int q, r, rr = 0, to = 0;
char *s, *e, *rp, *p, *rrp, *np, *cp, v;
BUF_MEM *buf;
if ((buf = BUF_MEM_new()) == NULL)
return 0;
- len = strlen(from) + 1;
- if (!BUF_MEM_grow(buf, len))
+ if (!BUF_MEM_grow(buf, strlen(from) + 1))
goto err;
for (;;) {
while (*p)
buf->data[to++] = *(p++);
- /*
- * Since we change the pointer 'from', we also have to change the
- * perceived length of the string it points at. /RL
- */
- len -= e - from;
from = e;
/*
static CONF_MODULE *module_find(const char *name)
{
CONF_MODULE *tmod;
- int i, nchar;
+ int i;
+ size_t nchar;
char *p;
STACK_OF(CONF_MODULE) *mods;
while (isspace((unsigned char)*tmpend))
tmpend--;
}
- ret = list_cb(lstart, tmpend - lstart + 1, arg);
+ ret = list_cb(lstart, (int)(tmpend - lstart + 1), arg);
}
if (ret <= 0)
return ret;
return 0;
HT_INIT_KEY(&key);
- HT_SET_KEY_STRING_CASE_N(&key, name, name, name_len);
+ HT_SET_KEY_STRING_CASE_N(&key, name, name, (int)name_len);
val = ossl_ht_get(namemap->namenum_ht, TO_HT_KEY(&key));
}
const char *ossl_namemap_num2name(const OSSL_NAMEMAP *namemap, int number,
- size_t idx)
+ int idx)
{
NAMES *names;
const char *ret = NULL;
goto err;
}
- if (!ASN1_INTEGER_set(pbm->iterationCount, itercnt)) {
+ if (!ASN1_INTEGER_set(pbm->iterationCount, (long)itercnt)) {
ERR_raise(ERR_LIB_CRMF, CRMF_R_CRMFERROR);
goto err;
}
}
if (_OPENSSL_isservice.p != (void *)-1)
- return (*_OPENSSL_isservice.f) ();
+ return (int)((*_OPENSSL_isservice.f)());
h = GetProcessWindowStation();
if (h == NULL)
fmt = (const TCHAR *)L"no stack?";
break;
}
- if (!MultiByteToWideChar(CP_ACP, 0, fmta, len_0, fmtw, len_0))
+ if (!MultiByteToWideChar(CP_ACP, 0, fmta, (int)len_0, fmtw, (int)len_0))
for (i = 0; i < len_0; i++)
fmtw[i] = (WCHAR)fmta[i];
for (i = 0; i < len_0; i++) {
int outlen, i;
unsigned char *outbuf = NULL;
- if (inlen == 0) {
+ if (inlen == 0 || inlen > INT_MAX) {
*out = NULL;
return 0;
}
- outlen = (inlen / 4) * 3;
+ outlen = (int)((inlen / 4) * 3);
outbuf = OPENSSL_malloc(outlen);
if (outbuf == NULL)
goto err;
- outlen = EVP_DecodeBlock(outbuf, (unsigned char *)in, inlen);
+ outlen = EVP_DecodeBlock(outbuf, (unsigned char *)in, (int)inlen);
if (outlen < 0) {
ERR_raise(ERR_LIB_CT, CT_R_BASE64_DECODE_ERROR);
goto err;
len_remaining -= siglen;
*in = p + siglen;
- return len - len_remaining;
+ return (int)(len - len_remaining);
}
SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len)
memcpy(p, sct->sig, sct->sig_len);
}
- return len;
+ return (int)len;
err:
OPENSSL_free(pstart);
return -1;
else
len = sct->sct_len;
+ if (len > INT_MAX)
+ return -1;
if (out == NULL)
- return len;
+ return (int)len;
if (*out != NULL) {
p = *out;
memcpy(p, sct->sct, len);
}
- return len;
+ return (int)len;
err:
OPENSSL_free(pstart);
return -1;
if (!is_pp_new)
*pp += len2;
}
- return len2;
+ return (int)len2;
err:
if (is_pp_new) {
if (sct->version != SCT_VERSION_V1) {
BIO_printf(out, "unknown\n%*s", indent + 16, "");
- BIO_hex_string(out, indent + 16, 16, sct->sct, sct->sct_len);
+ BIO_hex_string(out, indent + 16, 16, sct->sct, (int)sct->sct_len);
return;
}
}
BIO_printf(out, "\n%*sLog ID : ", indent + 4, "");
- BIO_hex_string(out, indent + 16, 16, sct->log_id, sct->log_id_len);
+ BIO_hex_string(out, indent + 16, 16, sct->log_id, (int)sct->log_id_len);
BIO_printf(out, "\n%*sTimestamp : ", indent + 4, "");
timestamp_print(sct->timestamp, out);
if (sct->ext_len == 0)
BIO_printf(out, "none");
else
- BIO_hex_string(out, indent + 16, 16, sct->ext, sct->ext_len);
+ BIO_hex_string(out, indent + 16, 16, sct->ext, (int)sct->ext_len);
BIO_printf(out, "\n%*sSignature : ", indent + 4, "");
SCT_signature_algorithms_print(sct, out);
BIO_printf(out, "\n%*s ", indent + 4, "");
- BIO_hex_string(out, indent + 16, 16, sct->sig, sct->sig_len);
+ BIO_hex_string(out, indent + 16, 16, sct->sig, (int)sct->sig_len);
}
void SCT_LIST_print(const STACK_OF(SCT) *sct_list, BIO *out, int indent,
void DES_string_to_key(const char *str, DES_cblock *key)
{
DES_key_schedule ks;
- int i, length;
+ int i;
+ size_t length;
memset(key, 0, 8);
length = strlen(str);
- for (i = 0; i < length; i++) {
+ if (length > INT_MAX)
+ length = INT_MAX;
+ for (i = 0; i < (int)length; i++) {
register unsigned char j = str[i];
if ((i % 16) < 8)
}
DES_set_odd_parity(key);
DES_set_key_unchecked(key, &ks);
- DES_cbc_cksum((const unsigned char *)str, key, length, &ks, key);
+ DES_cbc_cksum((const unsigned char *)str, key, (int)length, &ks, key);
OPENSSL_cleanse(&ks, sizeof(ks));
DES_set_odd_parity(key);
}
void DES_string_to_2keys(const char *str, DES_cblock *key1, DES_cblock *key2)
{
DES_key_schedule ks;
- int i, length;
+ int i;
+ size_t length;
memset(key1, 0, 8);
memset(key2, 0, 8);
length = strlen(str);
- for (i = 0; i < length; i++) {
+ if (length > INT_MAX)
+ length = INT_MAX;
+ for (i = 0; i < (int)length; i++) {
register unsigned char j = str[i];
if ((i % 32) < 16) {
DES_set_odd_parity(key1);
DES_set_odd_parity(key2);
DES_set_key_unchecked(key1, &ks);
- DES_cbc_cksum((const unsigned char *)str, key1, length, &ks, key1);
+ DES_cbc_cksum((const unsigned char *)str, key1, (int)length, &ks, key1);
DES_set_key_unchecked(key2, &ks);
- DES_cbc_cksum((const unsigned char *)str, key2, length, &ks, key2);
+ DES_cbc_cksum((const unsigned char *)str, key2, (int)length, &ks, key2);
OPENSSL_cleanse(&ks, sizeof(ks));
DES_set_odd_parity(key1);
DES_set_odd_parity(key2);
static int bits2int(BIGNUM *out, int qlen_bits,
const unsigned char *in, size_t inlen)
{
- int blen_bits = inlen * 8;
+ int blen_bits = (int)(inlen * 8);
int shift;
if (BN_bin2bn(in, (int)inlen, out) == NULL)
static int bits2int_consttime(BIGNUM *out, int qlen_bits,
const unsigned char *in, size_t inlen)
{
- int blen_bits = (inlen - sizeof(BN_ULONG)) * 8;
+ int blen_bits = (int)((inlen - sizeof(BN_ULONG)) * 8);
int shift;
if (BN_bin2bn(in, (int)inlen, out) == NULL)
dh = (DH *) EVP_PKEY_get0_DH(pkey);
if (dh == NULL)
return 0;
- return ossl_dh_key2buf(dh, arg2, 0, 1);
+ return (int)ossl_dh_key2buf(dh, arg2, 0, 1);
default:
return -2;
}
if (dhx->vparams != NULL) {
/* The counter has a maximum value of 4 * numbits(p) - 1 */
- size_t counter = (size_t)BN_get_word(dhx->vparams->counter);
+ int counter = (int)BN_get_word(dhx->vparams->counter);
ossl_ffc_params_set_validate_params(params, dhx->vparams->seed->data,
dhx->vparams->seed->length,
counter);
int DH_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
{
int ret = 0, i;
- volatile size_t npad = 0, mask = 1;
+ volatile int npad = 0, mask = 1;
/* compute the key; ret is constant unless compute_key is external */
#ifdef FIPS_MODULE
const BIGNUM *p;
int ret;
- if ((pubkey = BN_bin2bn(buf, len, NULL)) == NULL)
+ if (len > INT_MAX || (pubkey = BN_bin2bn(buf, (int)len, NULL)) == NULL)
goto err;
DH_get0_pqg(dh, &p, NULL, NULL);
if (p == NULL || BN_num_bytes(p) == 0) {
return 1;
case EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN:
- *(int *)p2 = dctx->kdf_outlen;
+ *(int *)p2 = (int)dctx->kdf_outlen;
return 1;
case EVP_PKEY_CTRL_DH_KDF_UKM:
case EVP_PKEY_CTRL_GET_DH_KDF_UKM:
*(unsigned char **)p2 = dctx->kdf_ukm;
- return dctx->kdf_ukmlen;
+ return (int)dctx->kdf_ukmlen;
case EVP_PKEY_CTRL_DH_KDF_OID:
ASN1_OBJECT_free(dctx->kdf_oid);
return 0;
}
- ret = DSA_sign(0, tbs, tbslen, sig, &sltmp, dsa);
+ ret = DSA_sign(0, tbs, (int)tbslen, sig, &sltmp, dsa);
if (ret <= 0)
return ret;
return 0;
}
- ret = DSA_verify(0, tbs, tbslen, sig, siglen, dsa);
+ ret = DSA_verify(0, tbs, (int)tbslen, sig, (int)siglen, dsa);
return ret;
}
(strstr(filename, ":") == NULL));
/* If transform != 0, then we convert to %s.dll, else just dupe filename */
- len = strlen(filename) + 1;
+ len = (int)strlen(filename) + 1;
if (transform)
- len += strlen(".dll");
+ len += (int)strlen(".dll");
translated = OPENSSL_malloc(len);
if (translated == NULL) {
ERR_raise(ERR_LIB_DSO, DSO_R_NAME_TRANSLATION_FAILED);
point_conversion_form_t form;
int y_bit, m;
BIGNUM *x, *y, *yxi;
- size_t field_len, enc_len;
+ int field_len, enc_len;
int ret = 0;
#ifndef FIPS_MODULE
BN_CTX *new_ctx = NULL;
(form ==
POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2 * field_len;
- if (len != enc_len) {
+ if (len != (size_t)enc_len) {
ERR_raise(ERR_LIB_EC, EC_R_INVALID_ENCODING);
return 0;
}
return EC_KEY_oct2key(evp_pkey_get0_EC_KEY_int(pkey), arg2, arg1, NULL);
case ASN1_PKEY_CTRL_GET1_TLS_ENCPT:
- return EC_KEY_key2buf(EVP_PKEY_get0_EC_KEY(pkey),
- POINT_CONVERSION_UNCOMPRESSED, arg2, NULL);
+ return (int)EC_KEY_key2buf(EVP_PKEY_get0_EC_KEY(pkey),
+ POINT_CONVERSION_UNCOMPRESSED, arg2, NULL);
default:
return -2;
int ok = 0;
BIGNUM *tmp_1 = NULL, *tmp_2 = NULL;
unsigned char *a_buf = NULL, *b_buf = NULL;
- size_t len;
+ int len;
if (!group || !curve || !curve->a || !curve->b)
return 0;
* definition of Curve, C.1's definition of FieldElement, and 2.3.5's
* definition of how to encode the field elements.
*/
- len = ((size_t)EC_GROUP_get_degree(group) + 7) / 8;
+ len = (EC_GROUP_get_degree(group) + 7) / 8;
if ((a_buf = OPENSSL_malloc(len)) == NULL
|| (b_buf = OPENSSL_malloc(len)) == NULL)
goto err;
form = EC_GROUP_get_point_conversion_form(group);
len = EC_POINT_point2buf(group, point, form, &buffer, NULL);
- if (len == 0) {
+ if (len == 0 || len > INT_MAX) {
ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
goto err;
}
- ASN1_STRING_set0(ret->base, buffer, len);
+ ASN1_STRING_set0(ret->base, buffer, (int)len);
/* set the order */
tmp = EC_GROUP_get0_order(group);
privlen = EC_KEY_priv2buf(a, &priv);
- if (privlen == 0) {
+ if (privlen == 0 || privlen > INT_MAX) {
ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
- ASN1_STRING_set0(priv_key->privateKey, priv, privlen);
+ ASN1_STRING_set0(priv_key->privateKey, priv, (int)privlen);
priv = NULL;
if (!(a->enc_flag & EC_PKEY_NO_PARAMETERS)) {
publen = EC_KEY_key2buf(a, a->conv_form, &pub, NULL);
- if (publen == 0) {
+ if (publen == 0 || publen > INT_MAX) {
ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
ossl_asn1_string_set_bits_left(priv_key->publicKey, 0);
- ASN1_STRING_set0(priv_key->publicKey, pub, publen);
+ ASN1_STRING_set0(priv_key->publicKey, pub, (int)publen);
pub = NULL;
}
buf_len = EC_POINT_point2oct(a->group, a->pub_key,
a->conv_form, NULL, 0, NULL);
+ if (buf_len > INT_MAX) {
+ ERR_raise(ERR_LIB_EC, ERR_R_PASSED_INVALID_ARGUMENT);
+ return 0;
+ }
if (out == NULL || buf_len == 0)
/* out == NULL => just return the length of the octet string */
- return buf_len;
+ return (int)buf_len;
if (*out == NULL) {
if ((*out = OPENSSL_malloc(buf_len)) == NULL)
}
if (!new_buffer)
*out += buf_len;
- return buf_len;
+ return (int)buf_len;
}
DECLARE_ASN1_FUNCTIONS(ECDSA_SIG)
buf_len = EC_POINT_point2buf(group, point, form, &buf, ctx);
- if (buf_len == 0)
+ if (buf_len == 0 || buf_len > INT_MAX)
return NULL;
- ret = BN_bin2bn(buf, buf_len, ret);
+ ret = BN_bin2bn(buf, (int)buf_len, ret);
OPENSSL_free(buf);
EC_POINT *EC_POINT_bn2point(const EC_GROUP *group,
const BIGNUM *bn, EC_POINT *point, BN_CTX *ctx)
{
- size_t buf_len = 0;
+ int buf_len = 0;
unsigned char *buf;
EC_POINT *ret;
size_t ossl_ec_key_simple_priv2oct(const EC_KEY *eckey,
unsigned char *buf, size_t len)
{
- size_t buf_len;
+ int buf_len;
buf_len = (EC_GROUP_order_bits(eckey->group) + 7) / 8;
if (eckey->priv_key == NULL)
return 0;
if (buf == NULL)
return buf_len;
- else if (len < buf_len)
+ else if (len < (size_t)buf_len)
return 0;
/* Octetstring may need leading zeros if BN is to short */
int ossl_ec_key_simple_oct2priv(EC_KEY *eckey, const unsigned char *buf,
size_t len)
{
+ if (len > INT_MAX) {
+ ERR_raise(ERR_LIB_EC, ERR_R_PASSED_INVALID_ARGUMENT);
+ return 0;
+ }
if (eckey->priv_key == NULL)
eckey->priv_key = BN_secure_new();
if (eckey->priv_key == NULL) {
ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
return 0;
}
- if (BN_bin2bn(buf, len, eckey->priv_key) == NULL) {
+ if (BN_bin2bn(buf, (int)len, eckey->priv_key) == NULL) {
ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
return 0;
}
memcpy(out, sec, outlen);
}
OPENSSL_clear_free(sec, seclen);
- return outlen;
+ return (int)outlen;
}
EC_KEY_METHOD *EC_KEY_METHOD_new(const EC_KEY_METHOD *meth)
num_val += (size_t)1 << (wsize[i] - 1);
wNAF[i + 1] = NULL; /* make sure we always have a pivot */
wNAF[i] =
- bn_compute_wNAF((i < num ? scalars[i] : scalar), wsize[i],
+ bn_compute_wNAF((i < num ? scalars[i] : scalar), (int)wsize[i],
&wNAF_len[i]);
if (wNAF[i] == NULL)
goto err;
* use the window size for which we have precomputation
*/
wsize[num] = pre_comp->w;
- tmp_wNAF = bn_compute_wNAF(scalar, wsize[num], &tmp_len);
+ tmp_wNAF = bn_compute_wNAF(scalar, (int)wsize[num], &tmp_len);
if (!tmp_wNAF)
goto err;
r_is_at_infinity = 1;
- for (k = max_len - 1; k >= 0; k--) {
+ if (max_len > INT_MAX)
+ goto err;
+ for (k = (int)(max_len - 1); k >= 0; k--) {
if (!r_is_at_infinity) {
if (!EC_POINT_dbl(group, r, r, ctx))
goto err;
type = (dctx->md != NULL) ? EVP_MD_get_type(dctx->md) : NID_sha1;
- ret = ECDSA_sign(type, tbs, tbslen, sig, &sltmp, ec);
+ ret = ECDSA_sign(type, tbs, (int)tbslen, sig, &sltmp, ec);
if (ret <= 0)
return ret;
else
type = NID_sha1;
- ret = ECDSA_verify(type, tbs, tbslen, sig, siglen, ec);
+ ret = ECDSA_verify(type, tbs, (int)tbslen, sig, (int)siglen, ec);
return ret;
}
return 1;
case EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN:
- *(int *)p2 = dctx->kdf_outlen;
+ *(int *)p2 = (int)dctx->kdf_outlen;
return 1;
case EVP_PKEY_CTRL_EC_KDF_UKM:
case EVP_PKEY_CTRL_GET_EC_KDF_UKM:
*(unsigned char **)p2 = dctx->kdf_ukm;
- return dctx->kdf_ukmlen;
+ return (int)dctx->kdf_ukmlen;
case EVP_PKEY_CTRL_MD:
if (EVP_MD_get_type((const EVP_MD *)p2) != NID_sha1 &&
int y_bit;
BN_CTX *new_ctx = NULL;
BIGNUM *x, *y;
- size_t field_len, enc_len;
+ int field_len, enc_len;
int ret = 0;
if (len == 0) {
(form ==
POINT_CONVERSION_COMPRESSED) ? 1 + field_len : 1 + 2 * field_len;
- if (len != enc_len) {
+ if (len != (size_t)enc_len) {
ERR_raise(ERR_LIB_EC, EC_R_INVALID_ENCODING);
return 0;
}
if (pkey->keymgmt != NULL)
libctx = ossl_provider_libctx(EVP_KEYMGMT_get0_provider(pkey->keymgmt));
- ecx = ossl_ecx_key_op(NULL, priv, len, pkey->ameth->pkey_id,
+ ecx = ossl_ecx_key_op(NULL, priv, (int)len, pkey->ameth->pkey_id,
KEY_OP_PRIVATE, libctx, NULL);
if (ecx != NULL) {
if (pkey->keymgmt != NULL)
libctx = ossl_provider_libctx(EVP_KEYMGMT_get0_provider(pkey->keymgmt));
- ecx = ossl_ecx_key_op(NULL, pub, len, pkey->ameth->pkey_id,
+ ecx = ossl_ecx_key_op(NULL, pub, (int)len, pkey->ameth->pkey_id,
KEY_OP_PUBLIC, libctx, NULL);
if (ecx != NULL) {
BIO *bio;
/* Index of the current decoder instance to be processed */
- size_t current_decoder_inst_index;
+ int current_decoder_inst_index;
/* For tracing, count recursion level */
- size_t recursion;
+ int recursion;
/*-
* Flags
* 1 to check that the decoder's input type differs from the decoder name
*/
enum { IS_SAME = 0, IS_DIFFERENT = 1 } type_check;
- size_t w_prev_start, w_prev_end; /* "previous" decoders */
- size_t w_new_start, w_new_end; /* "new" decoders */
+ int w_prev_start, w_prev_end; /* "previous" decoders */
+ int w_new_start, w_new_end; /* "new" decoders */
};
DEFINE_STACK_OF(OSSL_DECODER)
static void collect_extra_decoder(OSSL_DECODER *decoder, void *arg)
{
struct collect_extra_decoder_data_st *data = arg;
- size_t j;
+ int j;
const OSSL_PROVIDER *prov = OSSL_DECODER_get0_provider(decoder);
void *provctx = OSSL_PROVIDER_get0_provider_ctx(prov);
struct collect_extra_decoder_data_st data;
size_t depth = 0; /* Counts the number of iterations */
size_t count; /* Calculates how many were added in each iteration */
- size_t numdecoders;
+ int numdecoders;
STACK_OF(OSSL_DECODER) *skdecoders;
if (!ossl_assert(ctx != NULL)) {
data.w_prev_start = 0;
data.w_prev_end = sk_OSSL_DECODER_INSTANCE_num(ctx->decoder_insts);
do {
- size_t i, j;
+ int i, j;
data.w_new_start = data.w_new_end = data.w_prev_end;
OSSL_CORE_BIO *cbio = NULL;
BIO *bio = data->bio;
long loc;
- size_t i;
+ int i;
int ok = 0;
/* For recursions */
struct decoder_process_data_st new_data;
new_data.recursion = data->recursion + 1;
#define LEVEL_STR ">>>>>>>>>>>>>>>>"
-#define LEVEL (new_data.recursion < sizeof(LEVEL_STR) \
+#define LEVEL ((size_t)new_data.recursion < sizeof(LEVEL_STR) \
? &LEVEL_STR[sizeof(LEVEL_STR) - new_data.recursion - 1] \
: LEVEL_STR "...")
const OSSL_PARAM params[])
{
int ok = 1;
- size_t i;
- size_t l;
+ int i;
+ int l;
if (!ossl_assert(ctx != NULL)) {
ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_PASSED_NULL_PARAMETER);
const OSSL_PARAM params[])
{
int ok = 1;
- size_t i;
- size_t l;
+ int i;
+ int l;
if (!ossl_assert(ctx != NULL)) {
ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
cdp++;
return int_ctrl_cmd_is_null(cdp) ? 0 : cdp->cmd_num;
case ENGINE_CTRL_GET_NAME_LEN_FROM_CMD:
- return strlen(cdp->cmd_name);
+ return (int)strlen(cdp->cmd_name);
case ENGINE_CTRL_GET_NAME_FROM_CMD:
- return strlen(strcpy(s, cdp->cmd_name));
+ return (int)strlen(strcpy(s, cdp->cmd_name));
case ENGINE_CTRL_GET_DESC_LEN_FROM_CMD:
- return strlen(cdp->cmd_desc == NULL ? int_no_description
- : cdp->cmd_desc);
+ return (int)strlen(cdp->cmd_desc == NULL ? int_no_description
+ : cdp->cmd_desc);
case ENGINE_CTRL_GET_DESC_FROM_CMD:
- return strlen(strcpy(s, cdp->cmd_desc == NULL ? int_no_description
- : cdp->cmd_desc));
+ return (int)strlen(strcpy(s, cdp->cmd_desc == NULL ? int_no_description
+ : cdp->cmd_desc));
case ENGINE_CTRL_GET_CMD_FLAGS:
return cdp->cmd_flags;
}
if (!e->pkey_asn1_meths)
return NULL;
if (len == -1)
- len = strlen(str);
+ len = (int)strlen(str);
nidcount = e->pkey_asn1_meths(e, NULL, &nids, 0);
for (i = 0; i < nidcount; i++) {
e->pkey_asn1_meths(e, &ameth, NULL, nids[i]);
void ERR_add_error_vdata(int num, va_list args)
{
- int i, len, size;
+ int i;
+ size_t len, size;
int flags = ERR_TXT_MALLOCED | ERR_TXT_STRING;
char *str, *arg;
ERR_STATE *es;
}
str = p;
}
- OPENSSL_strlcat(str, arg, (size_t)size);
+ OPENSSL_strlcat(str, arg, size);
}
if (!err_set_error_data_int(str, size, flags, 0))
OPENSSL_free(str);
hex = ossl_buf2hexstr_sep((const unsigned char *)&tid, sizeof(tid), '\0');
BIO_snprintf(buf, sizeof(buf), "%s:", hex == NULL ? "<null>" : hex);
- offset = strlen(buf);
+ offset = (int)strlen(buf);
ossl_err_string_int(l, func, buf + offset, sizeof(buf) - offset);
- offset += strlen(buf + offset);
+ offset += (int)strlen(buf + offset);
BIO_snprintf(buf + offset, sizeof(buf) - offset, ":%s:%d:%s\n",
file, line, data);
OPENSSL_free(hex);
static int print_bio(const char *str, size_t len, void *bp)
{
- return BIO_write((BIO *)bp, str, len);
+ return BIO_write((BIO *)bp, str, (int)len);
}
void ERR_print_errors(BIO *bp)
void OSSL_ERR_STATE_save(ERR_STATE *es)
{
- size_t i;
+ int i;
ERR_STATE *thread_es;
if (es == NULL)
void OSSL_ERR_STATE_save_to_mark(ERR_STATE *es)
{
- size_t i, j, count;
+ int i, j, count;
int top;
ERR_STATE *thread_es;
void OSSL_ERR_STATE_restore(const ERR_STATE *es)
{
- size_t i;
+ int i;
ERR_STATE *thread_es;
if (es == NULL || es->bottom == es->top)
if (thread_es == NULL)
return;
- for (i = (size_t)es->bottom; i != (size_t)es->top;) {
- size_t top;
+ for (i = es->bottom; i != es->top;) {
+ int top;
i = (i + 1) % ERR_NUM_ERRORS;
if ((es->err_flags[i] & ERR_FLAG_CLEAR) != 0)
continue;
}
- k = EVP_DecodeUpdate(ctx->base64, ctx->buf, &num, p, q - p);
+ k = EVP_DecodeUpdate(ctx->base64, ctx->buf, &num, p, (int)(q - p));
EVP_DecodeInit(ctx->base64);
if (k <= 0 && num == 0) {
p = q;
ctx->start = 0;
if (p != ctx->tmp) {
- i -= p - ctx->tmp;
+ i -= (int)(p - ctx->tmp);
for (x = 0; x < i; x++)
ctx->tmp[x] = p[x];
}
}
} else if (p != q) {
/* Retain partial line at end of buffer */
- n = q - p;
+ n = (int)(q - p);
for (ii = 0; ii < n; ii++)
ctx->tmp[ii] = p[ii];
ctx->tmp_len = n;
static int b64_puts(BIO *b, const char *str)
{
- return b64_write(b, str, strlen(str));
+ size_t len = strlen(str);
+
+ if (len > INT_MAX)
+ return -1;
+ return b64_write(b, str, (int)len);
}
if (i > 0)
ctx->read_end += i;
} else {
- i = ctx->read_end - ctx->read_start;
+ i = (int)(ctx->read_end - ctx->read_start);
}
if (i <= 0) {
/* copy clean bytes to output buffer */
if (ctx->blockout) {
- i = ctx->buf_len - ctx->buf_off;
+ i = (int)(ctx->buf_len - ctx->buf_off);
if (i > outl)
i = outl;
memcpy(out, &(ctx->buf[ctx->buf_off]), i);
break;
/* no clean bytes in buffer -- fill it */
- n = IOBS - ctx->buf_len;
+ n = (int)(IOBS - ctx->buf_len);
i = BIO_read(next, &(ctx->buf[ctx->buf_len]), n);
if (i <= 0)
do {
BIO_clear_retry_flags(b);
- n = ctx->buf_len - ctx->buf_off;
+ n = (int)(ctx->buf_len - ctx->buf_off);
while (ctx->blockout && n > 0) {
i = BIO_write(next, &(ctx->buf[ctx->buf_off]), n);
if (i <= 0) {
break;
case BIO_CTRL_PENDING: /* More to read in buffer */
case BIO_CTRL_WPENDING: /* More to read in buffer */
- ret = ctx->blockout ? ctx->buf_len - ctx->buf_off : 0;
+ ret = ctx->blockout ? (long)(ctx->buf_len - ctx->buf_off) : 0;
if (ret <= 0)
ret = BIO_ctrl(next, cmd, num, ptr);
break;
if (md_size <= 0)
goto berr;
- tl = ctx->buf_len - OK_BLOCK_BLOCK;
+ tl = (unsigned long)(ctx->buf_len - OK_BLOCK_BLOCK);
ctx->buf[0] = (unsigned char)(tl >> 24);
ctx->buf[1] = (unsigned char)(tl >> 16);
ctx->buf[2] = (unsigned char)(tl >> 8);
= OPENSSL_malloc(ctx->buflen)) == NULL)
return 0;
if (BN_bn2nativepad(ctx->p2,
- ctx->allocated_buf, ctx->buflen) < 0) {
+ ctx->allocated_buf,
+ (int)ctx->buflen) < 0) {
OPENSSL_free(ctx->allocated_buf);
ctx->allocated_buf = NULL;
return 0;
ctx->p2 = (char *)(ctx->p2 == NULL
? OBJ_nid2sn(ctx->p1)
: get_name(ctx->p2));
- ctx->p1 = strlen(ctx->p2);
+ ctx->p1 = (int)strlen(ctx->p2);
} else if (state == POST_PARAMS_TO_CTRL && ctx->action_type == OSSL_ACTION_GET) {
ctx->p2 = (ctx->p2 == NULL ? "" : (char *)get_name(ctx->p2));
- ctx->p1 = strlen(ctx->p2);
+ ctx->p1 = (int)strlen(ctx->p2);
}
if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
}
if (ret <= 0)
goto end;
- ctx->p1 = strlen(ctx->p2);
+ ctx->p1 = (int)strlen(ctx->p2);
}
if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_VALUE);
return 0;
}
- ctx->p1 = strlen(ctx->p2);
+ ctx->p1 = (int)strlen(ctx->p2);
}
return default_fixup_args(state, translation, ctx);
return -2;
}
ctx->p2 = str_value_map[i].ptr;
- ctx->p1 = strlen(ctx->p2);
+ ctx->p1 = (int)strlen(ctx->p2);
}
if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
ctx->name_buf[sizeof(ctx->name_buf) - 1] = '\0';
}
ctx->p2 = ctx->name_buf;
- ctx->p1 = strlen(ctx->p2);
+ ctx->p1 = (int)strlen(ctx->p2);
}
if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
if (i == OSSL_NELEM(str_value_map))
return 0;
ctx->p2 = str_value_map[i].ptr;
- ctx->p1 = strlen(ctx->p2);
+ ctx->p1 = (int)strlen(ctx->p2);
}
if ((ret = default_fixup_args(state, translation, ctx)) <= 0)
if (ctx->p2 == NULL)
return 1;
- ctx->p1 = strlen(ctx->p2);
+ ctx->p1 = (int)strlen(ctx->p2);
return default_fixup_args(state, translation, ctx);
}
OPENSSL_assert(mdsize <= EVP_MAX_MD_SIZE);
ret = ctx->digest->final(ctx, md);
if (isize != NULL)
- *isize = mdsize;
+ *isize = (unsigned int)mdsize;
if (ctx->digest->cleanup) {
ctx->digest->cleanup(ctx);
EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
out += len;
/* Finally write tag */
CRYPTO_gcm128_tag(&gctx->gcm, out, EVP_GCM_TLS_TAG_LEN);
- rv = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
+ rv = (int)(len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN);
} else {
/* Decrypt */
if (gctx->ctr) {
OPENSSL_cleanse(out, len);
goto err;
}
- rv = len;
+ rv = (int)len;
}
err:
return -1;
}
}
- return len;
+ return (int)len;
} else {
if (!EVP_CIPHER_CTX_is_encrypting(ctx)) {
if (gctx->taglen < 0)
return -1;
if (!CRYPTO_ccm128_tag(ccm, out + len, cctx->M))
return -1;
- return len + EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->M;
+ return (int)(len + EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->M);
} else {
if (cctx->str ? !CRYPTO_ccm128_decrypt_ccm64(ccm, in, out, len,
cctx->str) :
unsigned char tag[16];
if (CRYPTO_ccm128_tag(ccm, tag, cctx->M)) {
if (!CRYPTO_memcmp(tag, in + len, cctx->M))
- return len;
+ return (int)len;
}
}
OPENSSL_cleanse(out, len);
15 - cctx->L, len))
return -1;
cctx->len_set = 1;
- return len;
+ return (int)len;
}
/* If have AAD need message length */
if (!cctx->len_set && len)
return -1;
CRYPTO_ccm128_aad(ccm, in, len);
- return len;
+ return (int)len;
}
/* The tag must be set before actually decrypting data */
CRYPTO_ccm128_encrypt(ccm, in, out, len))
return -1;
cctx->tag_set = 1;
- return len;
+ return (int)len;
} else {
int rv = -1;
if (cctx->str ? !CRYPTO_ccm128_decrypt_ccm64(ccm, in, out, len,
if (CRYPTO_ccm128_tag(ccm, tag, cctx->M)) {
if (!CRYPTO_memcmp(tag, EVP_CIPHER_CTX_buf_noconst(ctx),
cctx->M))
- rv = len;
+ rv = (int)len;
}
}
if (rv == -1)
/* If not padding input must be multiple of 8 */
if (!pad && inlen & 0x7)
return -1;
- if (ossl_is_partially_overlapping(out, in, inlen)) {
+ if (ossl_is_partially_overlapping(out, in, (int)inlen)) {
ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING);
return 0;
}
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);
}
}
if (pad) {
buf = octx->data_buf;
buf_len = &(octx->data_buf_len);
- if (ossl_is_partially_overlapping(out + *buf_len, in, len)) {
+ if (ossl_is_partially_overlapping(out + *buf_len, in, (int)len)) {
ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING);
return 0;
}
remaining = AES_BLOCK_SIZE - (*buf_len);
if (remaining > len) {
memcpy(buf + (*buf_len), in, len);
- *(buf_len) += len;
+ *(buf_len) += (int)len;
return 0;
}
memcpy(buf + (*buf_len), in, remaining);
(&octx->ocb, in, out, len - trailing_len))
return -1;
}
- written_len += len - trailing_len;
+ written_len += (int)(len - trailing_len);
in += len - trailing_len;
}
/* Handle any trailing partial block */
if (trailing_len > 0) {
memcpy(buf, in, trailing_len);
- *buf_len = trailing_len;
+ *buf_len = (int)trailing_len;
}
return written_len;
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;
- key->md.Nh += blocks >> 29;
- key->md.Nl += blocks <<= 3;
+ key->md.Nh += (unsigned int)(blocks >> 29);
+ key->md.Nl += (unsigned int)(blocks <<= 3);
if (key->md.Nl < (unsigned int)blocks)
key->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);
- key->aux.tls_aad[plen - 2] = inp_len >> 8;
- key->aux.tls_aad[plen - 1] = inp_len;
+ key->aux.tls_aad[plen - 2] = (unsigned char)(inp_len >> 8);
+ key->aux.tls_aad[plen - 1] = (unsigned char)inp_len;
/* calculate HMAC */
key->md = key->head;
}
/* but pretend as if we hashed padded payload */
- bitlen = key->md.Nl + (inp_len << 3); /* at most 18 bits */
+ bitlen = key->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;
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;
- key->md.Nh += blocks >> 29;
- key->md.Nl += blocks <<= 3;
+ key->md.Nh += (unsigned int)(blocks >> 29);
+ key->md.Nl += (unsigned int)(blocks <<= 3);
if (key->md.Nl < (unsigned int)blocks)
key->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);
- key->aux.tls_aad[plen - 2] = inp_len >> 8;
- key->aux.tls_aad[plen - 1] = inp_len;
+ key->aux.tls_aad[plen - 2] = (unsigned char)(inp_len >> 8);
+ key->aux.tls_aad[plen - 1] = (unsigned char)inp_len;
/* calculate HMAC */
key->md = key->head;
}
/* but pretend as if we hashed padded payload */
- bitlen = key->md.Nl + (inp_len << 3); /* at most 18 bits */
+ bitlen = key->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;
out += len;
/* Finally write tag */
CRYPTO_gcm128_tag(&gctx->gcm, out, EVP_GCM_TLS_TAG_LEN);
- rv = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
+ rv = (int)(len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN);
} else {
/* Decrypt */
if (CRYPTO_gcm128_decrypt(&gctx->gcm, in, out, len))
OPENSSL_cleanse(out, len);
goto err;
}
- rv = len;
+ rv = (int)len;
}
err:
if (CRYPTO_gcm128_decrypt(&gctx->gcm, in, out, len))
return -1;
}
- return len;
+ return (int)len;
}
if (!EVP_CIPHER_CTX_is_encrypting(ctx)) {
if (gctx->taglen < 0)
return -1;
if (!CRYPTO_ccm128_tag(ccm, out + len, cctx->M))
return -1;
- return len + EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->M;
+ return (int)(len + EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->M);
} else {
if (cctx->str ? !CRYPTO_ccm128_decrypt_ccm64(ccm, in, out, len, cctx->str)
: !CRYPTO_ccm128_decrypt(ccm, in, out, len)) {
unsigned char tag[16];
if (CRYPTO_ccm128_tag(ccm, tag, cctx->M)) {
if (!CRYPTO_memcmp(tag, in + len, cctx->M))
- return len;
+ return (int)len;
}
}
OPENSSL_cleanse(out, len);
if (CRYPTO_ccm128_setiv(ccm, ctx->iv, 15 - cctx->L, len))
return -1;
cctx->len_set = 1;
- return len;
+ return (int)len;
}
/* If have AAD need message length */
if (!cctx->len_set && len)
return -1;
CRYPTO_ccm128_aad(ccm, in, len);
- return len;
+ return (int)len;
}
/* The tag must be set before actually decrypting data */
: CRYPTO_ccm128_encrypt(ccm, in, out, len))
return -1;
cctx->tag_set = 1;
- return len;
+ return (int)len;
} else {
int rv = -1;
if (cctx->str ? !CRYPTO_ccm128_decrypt_ccm64(ccm, in, out, len,
if (CRYPTO_ccm128_tag(ccm, tag, cctx->M)) {
if (!CRYPTO_memcmp(tag, EVP_CIPHER_CTX_buf_noconst(ctx),
cctx->M))
- rv = len;
+ rv = (int)len;
}
}
if (rv == -1)
}
}
- return len;
+ return (int)len;
}
# else
static const unsigned char zero[CHACHA_BLK_SIZE] = { 0 };
Poly1305_Update(POLY1305_ctx(actx), in, len);
actx->len.aad += len;
actx->aad = 1;
- return len;
+ return (int)len;
} else { /* plain- or ciphertext */
if (actx->aad) { /* wrap up aad */
if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
return -1;
}
}
- return len;
+ return (int)len;
}
static int chacha20_poly1305_cleanup(EVP_CIPHER_CTX *ctx)
{
unsigned char icv[8], iv[8], sha1tmp[SHA_DIGEST_LENGTH];
int rv = -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 */
des_ede_cbc_cipher(ctx, icv, in, 8);
des_ede_cbc_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);
{
unsigned char sha1tmp[SHA_DIGEST_LENGTH];
if (out == NULL)
- return inl + 16;
+ return (int)(inl + 16);
/* Copy input to output buffer + 8 so we have space for IV */
memmove(out + 8, in, inl);
/* Work out ICV */
BUF_reverse(out, NULL, inl + 16);
memcpy(ctx->iv, wrap_iv, 8);
des_ede_cbc_cipher(ctx, out, out, inl + 16);
- return inl + 16;
+ return (int)(inl + 16);
}
static int des_ede3_wrap_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
if (inl >= EVP_MAXCHUNK || inl % 8)
return -1;
- if (ossl_is_partially_overlapping(out, in, inl)) {
+ if (ossl_is_partially_overlapping(out, in, (int)inl)) {
ERR_raise(ERR_LIB_EVP, EVP_R_PARTIALLY_OVERLAPPING);
return 0;
}
blocks *= MD5_CBLOCK;
rc4_off += blocks;
md5_off += blocks;
- key->md.Nh += blocks >> 29;
- key->md.Nl += blocks <<= 3;
+ key->md.Nh += (unsigned int)(blocks >> 29);
+ key->md.Nl += (unsigned int)(blocks <<= 3);
if (key->md.Nl < (unsigned int)blocks)
key->md.Nh++;
} else {
if (l < key->md.Nl)
key->md.Nh++;
key->md.Nl = l;
- key->md.Nh += blocks >> 29;
+ key->md.Nh += (unsigned int)(blocks >> 29);
} else {
md5_off = 0;
rc4_off = 0;
if (inl != 0)
memcpy(&(ctx->enc_data[0]), in, inl);
ctx->num = inl;
- *outl = total;
+ *outl = (int)total;
return 1;
}
in, inl_);
if (ossl_likely(ret)) {
- if (soutl > INT_MAX) {
+ if (ossl_unlikely(soutl > INT_MAX)) {
ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR);
return 0;
}
- *outl = soutl;
+ *outl = (int)soutl;
}
return ret;
ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
return 0;
}
- *outl = soutl;
+ *outl = (int)soutl;
}
return ret;
in, inl_);
if (ossl_likely(ret)) {
- if (soutl > INT_MAX) {
+ if (ossl_unlikely(soutl > INT_MAX)) {
ERR_raise(ERR_LIB_EVP, EVP_R_UPDATE_ERROR);
return 0;
}
- *outl = soutl;
+ *outl = (int)soutl;
}
return ret;
ERR_raise(ERR_LIB_EVP, EVP_R_FINAL_ERROR);
return 0;
}
- *outl = soutl;
+ *outl = (int)soutl;
}
return ret;
ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params);
if (ret <= 0)
goto end;
- return sz;
+ if (sz > INT_MAX)
+ return 0;
+ return (int)sz;
#ifndef OPENSSL_NO_RC2
case EVP_CTRL_GET_RC2_KEY_BITS:
set_params = 0; /* Fall thru */
OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE, &sz);
params[1] = OSSL_PARAM_construct_end();
ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params);
- if (ret <= 0)
+ if (ret <= 0 || sz > INT_MAX)
return 0;
- return sz;
+ return (int)sz;
case EVP_CTRL_TLS1_1_MULTIBLOCK_AAD: {
EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *p =
(EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *)ptr;
OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE, &p->interleave);
params[2] = OSSL_PARAM_construct_end();
ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params);
- if (ret <= 0)
+ if (ret <= 0 || sz > INT_MAX)
return 0;
- return sz;
+ return (int)sz;
}
case EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT: {
EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM *p =
OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN, &sz);
params[1] = OSSL_PARAM_construct_end();
ret = evp_do_ciph_ctx_getparams(ctx->cipher, ctx->algctx, params);
- if (ret <= 0)
+ if (ret <= 0 || sz > INT_MAX)
return 0;
- return sz;
+ return (int)sz;
}
#endif /* OPENSSL_NO_MULTIBLOCK */
case EVP_CTRL_AEAD_SET_MAC_KEY:
params[10] = OSSL_PARAM_construct_end();
ok = evp_do_ciph_getparams(cipher, params) > 0;
if (ok) {
- cipher->block_size = blksz;
- cipher->iv_len = ivlen;
- cipher->key_len = keylen;
+ cipher->block_size = (int)blksz;
+ cipher->iv_len = (int)ivlen;
+ cipher->key_len = (int)keylen;
cipher->flags = mode;
if (aead)
cipher->flags |= EVP_CIPH_FLAG_AEAD_CIPHER;
*/
params[0] = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_SIZE, &sz);
if (EVP_MD_CTX_get_params(c, params) != 1
- || sz == SIZE_MAX
+ || sz > INT_MAX
|| sz == 0)
return -1;
- return sz;
+ return (int)sz;
}
/* Normal digests have a constant fixed size output */
return EVP_MD_get_size(EVP_MD_CTX_get0_md(ctx));
ret = -2;
goto err;
}
- if (alg != NULL) {
+ if (alg != NULL && aid_len <= LONG_MAX) {
unsigned char *aid = NULL;
const unsigned char *pp = NULL;
pp = aid;
if (EVP_CIPHER_CTX_get_params(ctx, params)
&& OSSL_PARAM_modified(¶ms[0])
- && d2i_X509_ALGOR(alg, &pp, aid_len) != NULL)
+ && d2i_X509_ALGOR(alg, &pp, (long)aid_len) != NULL)
ret = 1;
}
OPENSSL_free(aid);
if (OSSL_PARAM_modified(¶ms[0])
/* ... but, we should get a return size too! */
&& derl != 0
+ && derl <= LONG_MAX
&& (der = OPENSSL_malloc(derl)) != NULL) {
unsigned char *derp = der;
if (EVP_PKEY_CTX_get_params(ctx, params)
&& OSSL_PARAM_modified(¶ms[0])
&& d2i_ASN1_TYPE(&type, (const unsigned char **)&derp,
- derl) != NULL) {
+ (long)derl) != NULL) {
/*
* Don't free alg->parameter, see comment further up.
* Worst case, alg->parameter gets assigned its own value.
ret = -2;
goto err;
}
- if (alg != NULL) {
+ if (alg != NULL && aid_len <= LONG_MAX) {
unsigned char *aid = NULL;
const unsigned char *pp = NULL;
pp = aid;
if (EVP_PKEY_CTX_get_params(ctx, params)
&& OSSL_PARAM_modified(¶ms[0])
- && d2i_X509_ALGOR(alg, &pp, aid_len) != NULL)
+ && d2i_X509_ALGOR(alg, &pp, (long)aid_len) != NULL)
ret = 1;
}
OPENSSL_free(aid);
if (pass == NULL)
passlen = 0;
else if (passlen == -1)
- passlen = strlen(pass);
+ passlen = (int)strlen(pass);
if (cipher_nid != -1) {
(void)ERR_set_mark();
int prediction_resistance,
const unsigned char *adin, size_t adin_len)
{
- int res;
+ size_t res;
if (!evp_rand_lock(ctx))
return 0;
vctx = 0;
if (ctx->flags & EVP_MD_CTX_FLAG_FINALISE) {
if (vctx) {
- r = pctx->pmeth->verifyctx(pctx, sig, siglen, ctx);
+ r = pctx->pmeth->verifyctx(pctx, sig, (int)siglen, ctx);
ctx->flags |= EVP_MD_CTX_FLAG_FINALISED;
} else
r = EVP_DigestFinal_ex(ctx, md, &mdlen);
}
if (vctx)
r = tmp_ctx->pctx->pmeth->verifyctx(tmp_ctx->pctx,
- sig, siglen, tmp_ctx);
+ sig, (int)siglen, tmp_ctx);
else
r = EVP_DigestFinal_ex(tmp_ctx, md, &mdlen);
EVP_MD_CTX_free(tmp_ctx);
if (pass == NULL)
passlen = 0;
else if (passlen == -1)
- passlen = strlen(pass);
+ passlen = (int)strlen(pass);
mdsize = EVP_MD_get_size(md);
if (mdsize <= 0)
pass = empty;
passlen = 0;
} else if (passlen == -1) {
- passlen = strlen(pass);
+ passlen = (int)strlen(pass);
}
if (salt == NULL && saltlen == 0)
salt = (unsigned char *)empty;
if (publen > INT_MAX)
return 0;
/* Historically this function was EVP_PKEY_set1_tls_encodedpoint */
- if (evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_SET1_TLS_ENCPT, publen,
+ if (evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_SET1_TLS_ENCPT, (int)publen,
(void *)pub) <= 0)
return 0;
return 1;
*/
ERR_set_mark();
- if (pkey_set_type(NULL, NULL, EVP_PKEY_NONE, name, strlen(name),
+ if (pkey_set_type(NULL, NULL, EVP_PKEY_NONE, name, (int)strlen(name),
NULL)) {
if (str[0] == NULL)
str[0] = name;
if (EVP_PKEY_decrypt(pctx, key, &keylen, ek, ekl) <= 0)
goto err;
- if (EVP_CIPHER_CTX_set_key_length(ctx, keylen) <= 0
+ if (EVP_CIPHER_CTX_set_key_length(ctx, (int)keylen) <= 0
|| !EVP_DecryptInit_ex(ctx, NULL, NULL, key, iv))
goto err;
goto err;
if (EVP_PKEY_sign(pkctx, sigret, &sltmp, m, m_len) <= 0)
goto err;
- *siglen = sltmp;
+ *siglen = (unsigned int)sltmp;
i = 1;
err:
EVP_PKEY_CTX_free(pkctx);
idx -= OSSL_NELEM(standard_methods);
if (idx >= (size_t)sk_EVP_PKEY_METHOD_num(app_pkey_methods))
return NULL;
- return sk_EVP_PKEY_METHOD_value(app_pkey_methods, idx);
+ return sk_EVP_PKEY_METHOD_value(app_pkey_methods, (int)idx);
}
#endif
len = strlen(str);
if (len > INT_MAX)
return -1;
- return ctx->pmeth->ctrl(ctx, cmd, len, (void *)str);
+ return ctx->pmeth->ctrl(ctx, cmd, (int)len, (void *)str);
}
int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex)
if (N == 0)
N = mdsize * 8;
- qsize = N >> 3;
+ qsize = (int)(N >> 3);
/*
* A.1.1.2 Step (1) AND
}
/* A.1.1.2 Step (11): max loop count = 4L - 1 */
- counter = 4 * L - 1;
+ counter = (int)(4 * L - 1);
/* Validation requires the counter to be supplied */
if (verify) {
/* A.1.1.3 Step (4) : if (counter > (4L -1)) return INVALID */
* A.1.1.3 Step (10)
* n = floor(L / hash_outlen) - 1
*/
- n = (L - 1) / (mdsize << 3);
+ n = (int)((L - 1) / (mdsize << 3));
/* Calculate 2^(L-1): Used in step A.1.1.2 Step (11.3) */
- if (!BN_lshift(test, BN_value_one(), L - 1))
+ if (!BN_lshift(test, BN_value_one(), (int)(L - 1)))
goto err;
for (;;) {
goto err;
memcpy(seed_tmp, seed, seedlen);
- r = generate_p(ctx, md, counter, n, seed_tmp, seedlen, q, p, L,
+ r = generate_p(ctx, md, counter, n, seed_tmp, seedlen, q, p, (int)L,
cb, &pcounter, res);
if (r > 0)
break; /* found p */
if (test == NULL)
goto err;
- if (!BN_lshift(test, BN_value_one(), L - 1))
+ if (!BN_lshift(test, BN_value_one(), (int)(L - 1)))
goto err;
if (!verify) {
goto err;
/* step 6 */
- n = (L - 1) / 160;
- counter = 4 * L - 1; /* Was 4096 */
+ n = (int)((L - 1) / 160);
+ counter = (int)(4 * L - 1); /* Was 4096 */
/* Validation requires the counter to be supplied */
if (verify) {
if (params->pcounter > counter) {
counter = params->pcounter;
}
- rv = generate_p(ctx, md, counter, n, buf, qsize, q, p, L, cb,
+ rv = generate_p(ctx, md, counter, n, buf, qsize, q, p, (int)L, cb,
&pcounter, res);
if (rv > 0)
break; /* found it */
size_t taglen;
taglen = hctx->aead_info->taglen;
- if (ctlen <= taglen || *ptlen < ctlen - taglen) {
+ if (ctlen <= taglen || *ptlen < ctlen - taglen
+ || aadlen > INT_MAX || ctlen > INT_MAX) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
goto err;
}
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,
- hctx->noncelen, NULL) != 1) {
+ (int)hctx->noncelen, NULL) != 1) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
goto err;
}
}
/* Provide AAD. */
if (aadlen != 0 && aad != NULL) {
- if (EVP_DecryptUpdate(ctx, NULL, &len, aad, aadlen) != 1) {
+ if (EVP_DecryptUpdate(ctx, NULL, &len, aad, (int)aadlen) != 1) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
goto err;
}
}
- if (EVP_DecryptUpdate(ctx, pt, &len, ct, ctlen - taglen) != 1) {
+ if (EVP_DecryptUpdate(ctx, pt, &len, ct, (int)(ctlen - taglen)) != 1) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
goto err;
}
*ptlen = len;
if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
- taglen, (void *)(ct + ctlen - taglen))) {
+ (int)taglen, (void *)(ct + ctlen - taglen))) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
goto err;
}
unsigned char tag[EVP_MAX_AEAD_TAG_LENGTH];
taglen = hctx->aead_info->taglen;
- if (*ctlen <= taglen || ptlen > *ctlen - taglen) {
+ if (*ctlen <= taglen || ptlen > *ctlen - taglen
+ || aadlen > INT_MAX || ptlen > INT_MAX) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
goto err;
}
if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,
- hctx->noncelen, NULL) != 1) {
+ (int)hctx->noncelen, NULL) != 1) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
goto err;
}
}
/* Provide any AAD data. */
if (aadlen != 0 && aad != NULL) {
- if (EVP_EncryptUpdate(ctx, NULL, &len, aad, aadlen) != 1) {
+ if (EVP_EncryptUpdate(ctx, NULL, &len, aad, (int)aadlen) != 1) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
goto err;
}
}
- if (EVP_EncryptUpdate(ctx, ct, &len, pt, ptlen) != 1) {
+ if (EVP_EncryptUpdate(ctx, ct, &len, pt, (int)ptlen) != 1) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
goto err;
}
}
*ctlen += len;
/* Get tag. Not a duplicate so needs to be added to the ciphertext */
- if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag) != 1) {
+ if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, (int)taglen, tag) != 1) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR);
goto err;
}
{
uint32_t rval = 0;
int err = 0;
- size_t sz = OSSL_NELEM(hpke_kem_tab);
+ uint32_t sz = OSSL_NELEM(hpke_kem_tab);
rval = ossl_rand_uniform_uint32(ctx, sz, &err);
return (err == 1 ? NULL : &hpke_kem_tab[rval]);
{
uint32_t rval = 0;
int err = 0;
- size_t sz = OSSL_NELEM(hpke_kdf_tab);
+ uint32_t sz = OSSL_NELEM(hpke_kdf_tab);
rval = ossl_rand_uniform_uint32(ctx, sz, &err);
return (err == 1 ? NULL : &hpke_kdf_tab[rval]);
uint32_t rval = 0;
int err = 0;
/* the minus 1 below is so we don't pick the EXPORTONLY codepoint */
- size_t sz = OSSL_NELEM(hpke_aead_tab) - 1;
+ uint32_t sz = OSSL_NELEM(hpke_aead_tab) - 1;
rval = ossl_rand_uniform_uint32(ctx, sz, &err);
return (err == 1 ? NULL : &hpke_aead_tab[rval]);
if (rctx->state == OHS_WRITE_HDR1)
rctx->state = OHS_WRITE_HDR;
rctx->pos += sz;
- rctx->len_to_send -= sz;
+ rctx->len_to_send -= (long)sz;
goto next_io;
}
if (rctx->state == OHS_WRITE_HDR) {
size_t outl;
char *out;
+ if (len > INT_MAX)
+ return 0;
/* Calculate size of encoded data */
outl = (len / 3);
if (len % 3 > 0)
if (out == NULL)
return 0;
- i = EVP_EncodeBlock((unsigned char *)out, buf, len);
+ i = EVP_EncodeBlock((unsigned char *)out, buf, (int)len);
if (!ossl_assert(0 <= i && (size_t)i <= outl)) {
OPENSSL_free(out);
return NULL;
char *temp = sh.freelist[slist];
/* remove from bigger list */
- OPENSSL_assert(!sh_testbit(temp, slist, sh.bitmalloc));
- sh_clearbit(temp, slist, sh.bittable);
+ OPENSSL_assert(!sh_testbit(temp, (int)slist, sh.bitmalloc));
+ sh_clearbit(temp, (int)slist, sh.bittable);
sh_remove_from_list(temp);
OPENSSL_assert(temp != sh.freelist[slist]);
slist++;
/* add to smaller list */
- OPENSSL_assert(!sh_testbit(temp, slist, sh.bitmalloc));
- sh_setbit(temp, slist, sh.bittable);
+ OPENSSL_assert(!sh_testbit(temp, (int)slist, sh.bitmalloc));
+ sh_setbit(temp, (int)slist, sh.bittable);
sh_add_to_list(&sh.freelist[slist], temp);
OPENSSL_assert(sh.freelist[slist] == temp);
/* split in 2 */
temp += sh.arena_size >> slist;
- OPENSSL_assert(!sh_testbit(temp, slist, sh.bitmalloc));
- sh_setbit(temp, slist, sh.bittable);
+ OPENSSL_assert(!sh_testbit(temp, (int)slist, sh.bitmalloc));
+ sh_setbit(temp, (int)slist, sh.bittable);
sh_add_to_list(&sh.freelist[slist], temp);
OPENSSL_assert(sh.freelist[slist] == temp);
- OPENSSL_assert(temp-(sh.arena_size >> slist) == sh_find_my_buddy(temp, slist));
+ OPENSSL_assert(temp-(sh.arena_size >> slist) == sh_find_my_buddy(temp, (int)slist));
}
/* peel off memory to hand back */
chunk = sh.freelist[list];
- OPENSSL_assert(sh_testbit(chunk, list, sh.bittable));
- sh_setbit(chunk, list, sh.bitmalloc);
+ OPENSSL_assert(sh_testbit(chunk, (int)list, sh.bittable));
+ sh_setbit(chunk, (int)list, sh.bitmalloc);
sh_remove_from_list(chunk);
OPENSSL_assert(WITHIN_ARENA(chunk));
return;
list = sh_getlist(ptr);
- OPENSSL_assert(sh_testbit(ptr, list, sh.bittable));
- sh_clearbit(ptr, list, sh.bitmalloc);
+ OPENSSL_assert(sh_testbit(ptr, (int)list, sh.bittable));
+ sh_clearbit(ptr, (int)list, sh.bitmalloc);
sh_add_to_list(&sh.freelist[list], ptr);
/* Try to coalesce two adjacent free areas. */
- while ((buddy = sh_find_my_buddy(ptr, list)) != NULL) {
- OPENSSL_assert(ptr == sh_find_my_buddy(buddy, list));
+ while ((buddy = sh_find_my_buddy(ptr, (int)list)) != NULL) {
+ OPENSSL_assert(ptr == sh_find_my_buddy(buddy, (int)list));
OPENSSL_assert(ptr != NULL);
- OPENSSL_assert(!sh_testbit(ptr, list, sh.bitmalloc));
- sh_clearbit(ptr, list, sh.bittable);
+ OPENSSL_assert(!sh_testbit(ptr, (int)list, sh.bitmalloc));
+ sh_clearbit(ptr, (int)list, sh.bittable);
sh_remove_from_list(ptr);
- OPENSSL_assert(!sh_testbit(ptr, list, sh.bitmalloc));
- sh_clearbit(buddy, list, sh.bittable);
+ OPENSSL_assert(!sh_testbit(ptr, (int)list, sh.bitmalloc));
+ sh_clearbit(buddy, (int)list, sh.bittable);
sh_remove_from_list(buddy);
list--;
if (ptr > buddy)
ptr = buddy;
- OPENSSL_assert(!sh_testbit(ptr, list, sh.bitmalloc));
- sh_setbit(ptr, list, sh.bittable);
+ OPENSSL_assert(!sh_testbit(ptr, (int)list, sh.bitmalloc));
+ sh_setbit(ptr, (int)list, sh.bittable);
sh_add_to_list(&sh.freelist[list], ptr);
OPENSSL_assert(sh.freelist[list] == ptr);
}
OPENSSL_assert(WITHIN_ARENA(ptr));
if (!WITHIN_ARENA(ptr))
return 0;
- list = sh_getlist(ptr);
+ list = (int)sh_getlist(ptr);
OPENSSL_assert(sh_testbit(ptr, list, sh.bittable));
return sh.arena_size / (ONE << list);
}
*/
static int hint_bits_encode(const VECTOR *hint, WPACKET *pkt, uint32_t omega)
{
- int i, j, k = hint->num_poly;
+ int i, j, k = (int)hint->num_poly;
size_t coeff_index = 0;
POLY *p = hint->poly;
uint8_t *data;
VECTOR *t1, VECTOR *t0)
{
const ML_DSA_PARAMS *params = key->params;
- uint32_t k = params->k, l = params->l;
+ uint32_t k = (uint32_t)params->k, l = (uint32_t)params->l;
POLY *polys;
MATRIX a_ntt;
VECTOR s1_ntt;
int ret = 0;
VECTOR t1, t0;
POLY *polys = NULL;
- uint32_t k = key->params->k;
+ uint32_t k = (uint32_t)key->params->k;
EVP_MD_CTX *md_ctx = NULL;
if (key->pub_encoding == NULL || key->priv_encoding == 0)
int ret = 0;
const ML_DSA_PARAMS *params = priv->params;
EVP_MD_CTX *md_ctx = NULL;
- uint32_t k = params->k, l = params->l;
+ uint32_t k = (uint32_t)params->k, l = (uint32_t)params->l;
uint32_t gamma1 = params->gamma1, gamma2 = params->gamma2;
uint8_t *alloc = NULL, *w1_encoded;
size_t alloc_len, w1_encoded_len;
VECTOR *ct0 = &w1;
uint32_t z_max, r0_max, ct0_max, h_ones;
- vector_expand_mask(&y, rho_prime, sizeof(rho_prime), kappa,
+ vector_expand_mask(&y, rho_prime, sizeof(rho_prime), (uint32_t)kappa,
gamma1, md_ctx, priv->shake256_md);
vector_copy(y_ntt, &y);
vector_ntt(y_ntt);
w1_encoded, w1_encoded_len, c_tilde, c_tilde_len))
break;
- if (!poly_sample_in_ball_ntt(c_ntt, c_tilde, c_tilde_len,
+ if (!poly_sample_in_ball_ntt(c_ntt, c_tilde, (int)c_tilde_len,
md_ctx, priv->shake256_md, params->tau))
break;
vector_make_hint(ct0, &cs2, &w, gamma2, &sig.hint);
ct0_max = vector_max(ct0);
- h_ones = vector_count_ones(&sig.hint);
+ h_ones = (uint32_t)vector_count_ones(&sig.hint);
/* Same reasoning applies to the leak as above */
if (value_barrier_32(constant_time_ge(ct0_max, gamma2)
| constant_time_lt(params->omega, h_ones)))
VECTOR az_ntt, ct1_ntt, *z_ntt, *w1, *w_approx;
ML_DSA_SIG sig;
const ML_DSA_PARAMS *params = pub->params;
- uint32_t k = pub->params->k;
- uint32_t l = pub->params->l;
+ uint32_t k = (uint32_t)pub->params->k;
+ uint32_t l = (uint32_t)pub->params->l;
uint32_t gamma2 = params->gamma2;
size_t w1_encoded_len;
size_t num_polys_sig = k + l;
goto err;
/* Compute verifiers challenge c_ntt = NTT(SampleInBall(c_tilde)) */
- if (!poly_sample_in_ball_ntt(c_ntt, c_tilde_sig, c_tilde_len,
+ if (!poly_sample_in_ball_ntt(c_ntt, c_tilde_sig, (int)c_tilde_len,
md_ctx, pub->shake256_md, params->tau))
goto err;
const size_t padding_len = padded_len - inlen;
/* RFC 5649 section 3: Alternative Initial Value */
unsigned char aiv[8];
- int ret;
+ size_t ret;
/* Section 1: use 32-bit fixed field for plaintext octet length */
if (inlen == 0 || inlen >= CRYPTO128_WRAP_MAX)
if (MultiByteToWideChar(CP_UTF8, flags,
filename, len_0, wfilename, sz) &&
- MultiByteToWideChar(CP_UTF8, 0, mode, strlen(mode) + 1,
+ MultiByteToWideChar(CP_UTF8, 0, mode, (int)(strlen(mode) + 1),
wmode, OSSL_NELEM(wmode)) &&
(file = _wfopen(wfilename, wmode)) == NULL &&
(errno == ENOENT || errno == EBADF)
char *CRYPTO_strdup(const char *str, const char* file, int line)
{
char *ret;
+ size_t len;
if (str == NULL)
return NULL;
- ret = CRYPTO_malloc(strlen(str) + 1, file, line);
+
+ len = strlen(str) + 1;
+ ret = CRYPTO_malloc(len, file, line);
if (ret != NULL)
- strcpy(ret, str);
+ memcpy(ret, str, len);
return ret;
}
bndec = BN_bn2dec(bl);
if (!bndec)
goto err;
- i = strlen(bndec);
+ i = (int)strlen(bndec);
if (buf != NULL) {
if (buf_len > 1) {
*buf++ = '.';
OPENSSL_free(bndec);
} else {
BIO_snprintf(tbuf, sizeof(tbuf), ".%lu", l);
- i = strlen(tbuf);
+ i = (int)strlen(tbuf);
if (buf && buf_len > 0) {
OPENSSL_strlcpy(buf, tbuf, buf_len);
if (i > buf_len) {
if (ossl_quic_vlint_encode_len(value) > len)
return 0;
- ossl_quic_vlint_encode_n(data, value, len);
+ ossl_quic_vlint_encode_n(data, value, (int)len);
return 1;
}
#endif
if (pd->bn != NULL) {
/* BIGNUM */
if (pd->type == OSSL_PARAM_UNSIGNED_INTEGER)
- BN_bn2nativepad(pd->bn, (unsigned char *)p, pd->size);
+ BN_bn2nativepad(pd->bn, (unsigned char *)p, (int)pd->size);
else
- BN_signed_bn2native(pd->bn, (unsigned char *)p, pd->size);
+ BN_signed_bn2native(pd->bn, (unsigned char *)p, (int)pd->size);
} else if (pd->type == OSSL_PARAM_OCTET_PTR
|| pd->type == OSSL_PARAM_UTF8_PTR) {
/* PTR */
switch (p->data_type) {
case OSSL_PARAM_UNSIGNED_INTEGER:
- if (BN_bn2nativepad(val, p->data, p->data_size) < 0) {
+ if (BN_bn2nativepad(val, p->data, (int)p->data_size) < 0) {
ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_INTEGER_OVERFLOW);
return 0;
}
break;
case OSSL_PARAM_INTEGER:
- if (BN_signed_bn2native(val, p->data, p->data_size) < 0) {
+ if (BN_signed_bn2native(val, p->data, (int)p->data_size) < 0) {
ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_INTEGER_OVERFLOW);
return 0;
}
}
*/
- BN_bn2nativepad(tmpbn, buf, buf_n);
+ BN_bn2nativepad(tmpbn, buf, (int)buf_n);
/*
* 2's complement negation, part two.
}
break;
case OSSL_PARAM_UTF8_PTR:
- ok = BIO_dump(bio, p->data, p->data_size);
+ ok = BIO_dump(bio, p->data, (int)p->data_size);
break;
case OSSL_PARAM_UTF8_STRING:
- ok = BIO_dump(bio, (char *)p->data, p->data_size);
+ ok = BIO_dump(bio, (char *)p->data, (int)p->data_size);
break;
case OSSL_PARAM_OCTET_PTR:
case OSSL_PARAM_OCTET_STRING:
- ok = BIO_dump(bio, (char *)p->data, p->data_size);
+ ok = BIO_dump(bio, (char *)p->data, (int)p->data_size);
break;
#ifndef OPENSSL_SYS_UEFI
case OSSL_PARAM_REAL:
prompt_idx = UI_add_input_string(ui, prompt,
UI_INPUT_FLAG_DEFAULT_PWD,
- ipass, 0, pass_size) - 1;
+ ipass, 0, (int)pass_size) - 1;
if (prompt_idx < 0) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_UI_LIB);
goto end;
goto end;
verify_idx = UI_add_verify_string(ui, prompt,
UI_INPUT_FLAG_DEFAULT_PWD,
- vpass, 0, pass_size,
+ vpass, 0, (int)pass_size,
ipass) - 1;
if (verify_idx < 0) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_UI_LIB);
/* We assume that the user passes a default password as userdata */
if (userdata) {
- i = strlen(userdata);
+ i = (int)strlen(userdata);
i = (i > num) ? num : i;
memcpy(buf, userdata, i);
return i;
memset(buf, 0, (unsigned int)num);
return -1;
}
- return strlen(buf);
+ return (int)strlen(buf);
}
void PEM_proc_type(char *buf, int type)
{
long i;
char *p = buf + strlen(buf);
- int j = PEM_BUFSIZE - (size_t)(p - buf), n;
+ int j = PEM_BUFSIZE - (int)(p - buf), n;
n = BIO_snprintf(p, j, "DEK-Info: %s,", type);
if (n > 0) {
}
EVP_EncodeInit(ctx);
- nlen = strlen(name);
+ nlen = (int)strlen(name);
if ((BIO_write(bp, "-----BEGIN ", 11) != 11) ||
(BIO_write(bp, name, nlen) != nlen) ||
goto err;
}
- i = header != NULL ? strlen(header) : 0;
+ i = header != NULL ? (int)strlen(header) : 0;
if (i > 0) {
if ((BIO_write(bp, header, i) != i) || (BIO_write(bp, "\n", 1) != 1)) {
reason = ERR_R_BIO_LIB;
goto end;
BIO_get_mem_ptr(dataB, &buf_mem);
- len = buf_mem->length;
+ if (buf_mem->length > INT_MAX) {
+ ERR_raise(ERR_LIB_PEM, PEM_R_BAD_BASE64_DECODE);
+ goto end;
+ }
+ len = (int)buf_mem->length;
/* There was no data in the PEM file */
if (len == 0)
int ossl_pem_check_suffix(const char *pem_str, const char *suffix)
{
- int pem_len = strlen(pem_str);
- int suffix_len = strlen(suffix);
+ int pem_len = (int)strlen(pem_str);
+ int suffix_len = (int)strlen(suffix);
const char *p;
+
if (suffix_len + 1 >= pem_len)
return 0;
p = pem_str + pem_len - suffix_len;
p--;
if (*p != ' ')
return 0;
- return p - pem_str;
+ return (int)(p - pem_str);
}
if (kstr == NULL && cb == NULL) { \
if (u != NULL) { \
kstr = u; \
- klen = strlen(u); \
+ klen = (int)strlen(u); \
} else { \
cb = PEM_def_callback; \
} \
if (kstr == NULL && cb == NULL) {
if (u != NULL) {
kstr = u;
- klen = strlen(u);
+ klen = (int)strlen(u);
} else {
cb = PEM_def_callback;
}
unsigned char *unitmp;
if (asclen == -1)
- asclen = strlen(asc);
+ asclen = (int)strlen(asc);
if (asclen < 0)
return NULL;
ulen = asclen * 2 + 2;
unsigned long utf32chr = 0;
if (asclen == -1)
- asclen = strlen(asc);
+ asclen = (int)strlen(asc);
for (ulen = 0, i = 0; i < asclen; i += j) {
j = UTF8_getc((const unsigned char *)asc+i, asclen-i, &utf32chr);
if (EVP_PKEY_encrypt(pctx, ek, &eklen, key, keylen) <= 0)
goto err;
- ASN1_STRING_set0(ri->enc_key, ek, eklen);
+ ASN1_STRING_set0(ri->enc_key, ek, (int)eklen);
ek = NULL;
ret = 1;
OPENSSL_clear_free(*pek, *peklen);
*pek = ek;
- *peklen = eklen;
+ *peklen = (int)eklen;
err:
EVP_PKEY_CTX_free(pctx);
EVP_MD_CTX_free(mctx);
- ASN1_STRING_set0(si->enc_digest, abuf, siglen);
+ ASN1_STRING_set0(si->enc_digest, abuf, (int)siglen);
return 1;
if (!ossl_property_read_lock(store))
return;
-
+
tmpalgs = sk_ALGORITHM_new_reserve(NULL,
- ossl_sa_ALGORITHM_num(store->algs));
+ (int)ossl_sa_ALGORITHM_num(store->algs));
if (tmpalgs == NULL) {
ossl_property_unlock(store);
return;
#ifndef FIPS_MODULE
OSSL_TRACE_BEGIN(QUERY) {
char buf[512];
- int size;
+ size_t size;
size = ossl_property_list_to_string(NULL, pq, buf, 512);
BIO_printf(trc_out, "method store query with properties %s "
unsigned int n = initial_n;
unsigned int i = 0;
unsigned int bias = initial_bias;
- size_t processed_in = 0, written_out = 0;
+ unsigned int processed_in = 0;
+ unsigned int written_out = 0;
unsigned int max_out = *pout_length;
unsigned int basic_count = 0;
unsigned int loop;
- for (loop = 0; loop < enc_len; loop++) {
+ if (enc_len >= UINT_MAX)
+ return 0;
+ for (loop = 0; loop < (unsigned int)enc_len; loop++) {
if (pEncoded[loop] == delimiter)
basic_count = loop;
}
processed_in = basic_count + 1;
}
- for (loop = processed_in; loop < enc_len;) {
+ for (loop = processed_in; loop < (unsigned int)enc_len;) {
unsigned int oldi = i;
unsigned int w = 1;
unsigned int k, t;
void ossl_quic_vlint_encode(uint8_t *buf, uint64_t v)
{
- ossl_quic_vlint_encode_n(buf, v, ossl_quic_vlint_encode_len(v));
+ ossl_quic_vlint_encode_n(buf, v, (int)ossl_quic_vlint_encode_len(v));
}
uint64_t ossl_quic_vlint_decode_unchecked(const unsigned char *buf)
x = ossl_quic_vlint_decode_unchecked(buf);
*v = x;
- return dec_len;
+ return (int)dec_len;
}
#endif
if (meth->add == NULL
|| meth->add(ossl_rand_pool_buffer(pool),
- ossl_rand_pool_length(pool),
+ (int)ossl_rand_pool_length(pool),
(ossl_rand_pool_entropy(pool) / 8.0)) == 0)
goto err;
const RAND_METHOD *meth = RAND_get_rand_method();
if (meth != NULL && meth != RAND_OpenSSL()) {
+ if (num > INT_MAX) {
+ ERR_raise(ERR_LIB_RAND, RAND_R_ARGUMENT_OUT_OF_RANGE);
+ return -1;
+ }
if (meth->bytes != NULL)
- return meth->bytes(buf, num);
+ return meth->bytes(buf, (int)num);
ERR_raise(ERR_LIB_RAND, RAND_R_FUNC_NOT_IMPLEMENTED);
return -1;
}
const RAND_METHOD *meth = RAND_get_rand_method();
if (meth != NULL && meth != RAND_OpenSSL()) {
+ if (num > INT_MAX) {
+ ERR_raise(ERR_LIB_RAND, RAND_R_ARGUMENT_OUT_OF_RANGE);
+ return -1;
+ }
if (meth->bytes != NULL)
- return meth->bytes(buf, num);
+ return meth->bytes(buf, (int)num);
ERR_raise(ERR_LIB_RAND, RAND_R_FUNC_NOT_IMPLEMENTED);
return -1;
}
n = (bytes <= RAND_LOAD_BUF_SIZE) ? (int)bytes : RAND_BUF_SIZE;
else
n = RAND_LOAD_BUF_SIZE;
- i = fread(buf, 1, n, in);
+ i = (int)fread(buf, 1, n, in);
#ifdef EINTR
if (ferror(in) && errno == EINTR) {
clearerr(in);
chmod(file, 0600);
#endif
- ret = fwrite(buf, 1, RAND_BUF_SIZE, out);
+ ret = (int)fwrite(buf, 1, RAND_BUF_SIZE, out);
fclose(out);
OPENSSL_cleanse(buf, RAND_BUF_SIZE);
return ret;
if (alg1 != NULL) {
const unsigned char *pp = aid;
- if (d2i_X509_ALGOR(&alg1, &pp, aid_len) == NULL)
+ if (d2i_X509_ALGOR(&alg1, &pp, (long)aid_len) == NULL)
return 0;
}
if (alg2 != NULL) {
const unsigned char *pp = aid;
- if (d2i_X509_ALGOR(&alg2, &pp, aid_len) == NULL)
+ if (d2i_X509_ALGOR(&alg2, &pp, (long)aid_len) == NULL)
return 0;
}
unsigned int sltmp;
if (rctx->pad_mode != RSA_PKCS1_PADDING)
return -1;
- ret = RSA_sign_ASN1_OCTET_STRING(0, tbs, tbslen, sig, &sltmp, rsa);
+ ret = RSA_sign_ASN1_OCTET_STRING(0, tbs, (int)tbslen, sig, &sltmp, rsa);
if (ret <= 0)
return ret;
}
memcpy(rctx->tbuf, tbs, tbslen);
rctx->tbuf[tbslen] = RSA_X931_hash_id(EVP_MD_get_type(rctx->md));
- ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf,
+ ret = RSA_private_encrypt((int)(tbslen + 1), rctx->tbuf,
sig, rsa, RSA_X931_PADDING);
} else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
unsigned int sltmp;
ret = RSA_sign(EVP_MD_get_type(rctx->md),
- tbs, tbslen, sig, &sltmp, rsa);
+ tbs, (unsigned int)tbslen, sig, &sltmp, rsa);
if (ret <= 0)
return ret;
ret = sltmp;
return -1;
}
} else {
- ret = RSA_private_encrypt(tbslen, tbs, sig, rsa, rctx->pad_mode);
+ ret = RSA_private_encrypt((int)tbslen, tbs, sig, rsa, rctx->pad_mode);
}
if (ret < 0)
return ret;
if (rctx->pad_mode == RSA_X931_PADDING) {
if (!setup_tbuf(rctx, ctx))
return -1;
- ret = RSA_public_decrypt(siglen, sig, rctx->tbuf, rsa,
+ ret = RSA_public_decrypt((int)siglen, sig, rctx->tbuf, rsa,
RSA_X931_PADDING);
if (ret < 1)
return 0;
sig, siglen, rsa);
if (ret <= 0)
return 0;
- ret = sltmp;
+ ret = (int)sltmp;
} else {
return -1;
}
} else {
- ret = RSA_public_decrypt(siglen, sig, rout, rsa, rctx->pad_mode);
+ ret = RSA_public_decrypt((int)siglen, sig, rout, rsa, rctx->pad_mode);
}
if (ret < 0)
return ret;
if (rctx->md) {
if (rctx->pad_mode == RSA_PKCS1_PADDING)
- return RSA_verify(EVP_MD_get_type(rctx->md), tbs, tbslen,
- sig, siglen, rsa);
+ return RSA_verify(EVP_MD_get_type(rctx->md), tbs, (unsigned int)tbslen,
+ sig, (unsigned int)siglen, rsa);
md_size = EVP_MD_get_size(rctx->md);
if (md_size <= 0) {
ERR_raise(ERR_LIB_RSA, RSA_R_INVALID_DIGEST_LENGTH);
int ret;
if (!setup_tbuf(rctx, ctx))
return -1;
- ret = RSA_public_decrypt(siglen, sig, rctx->tbuf,
+ ret = RSA_public_decrypt((int)siglen, sig, rctx->tbuf,
rsa, RSA_NO_PADDING);
if (ret <= 0)
return 0;
} else {
if (!setup_tbuf(rctx, ctx))
return -1;
- rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf,
+ rslen = RSA_public_decrypt((int)siglen, sig, rctx->tbuf,
rsa, rctx->pad_mode);
if (rslen == 0)
return 0;
if (!setup_tbuf(rctx, ctx))
return -1;
if (!RSA_padding_add_PKCS1_OAEP_mgf1(rctx->tbuf, klen,
- in, inlen,
+ in, (int)inlen,
rctx->oaep_label,
- rctx->oaep_labellen,
+ (int)rctx->oaep_labellen,
rctx->md, rctx->mgf1md))
return -1;
ret = RSA_public_encrypt(klen, rctx->tbuf, out, rsa, RSA_NO_PADDING);
} else {
- ret = RSA_public_encrypt(inlen, in, out, rsa, rctx->pad_mode);
+ ret = RSA_public_encrypt((int)inlen, in, out, rsa, rctx->pad_mode);
}
if (ret < 0)
return ret;
if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
if (!setup_tbuf(rctx, ctx))
return -1;
- ret = RSA_private_decrypt(inlen, in, rctx->tbuf, rsa, RSA_NO_PADDING);
+ ret = RSA_private_decrypt((int)inlen, in, rctx->tbuf, rsa, RSA_NO_PADDING);
if (ret <= 0)
return ret;
ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, ret, rctx->tbuf,
ret, ret,
rctx->oaep_label,
- rctx->oaep_labellen,
+ (int)rctx->oaep_labellen,
rctx->md, rctx->mgf1md);
} else {
if (rctx->pad_mode == RSA_PKCS1_PADDING &&
pad_mode = RSA_PKCS1_NO_IMPLICIT_REJECT_PADDING;
else
pad_mode = rctx->pad_mode;
- ret = RSA_private_decrypt(inlen, in, out, rsa, pad_mode);
+ ret = RSA_private_decrypt((int)inlen, in, out, rsa, pad_mode);
}
*outlen = constant_time_select_s(constant_time_msb_s(ret), *outlen, ret);
ret = constant_time_select_int(constant_time_msb(ret), ret, 1);
return 0;
}
*(unsigned char **)p2 = rctx->oaep_label;
- return rctx->oaep_labellen;
+ return (int)rctx->oaep_labellen;
case EVP_PKEY_CTRL_RSA_IMPLICIT_REJECTION:
if (rctx->pad_mode != RSA_PKCS1_PADDING) {
*/
/* Start by adjusting the stored size, to make things easier */
- ctx->hash_size = siphash_adjust_hash_size(ctx->hash_size);
+ ctx->hash_size = (unsigned int)siphash_adjust_hash_size(ctx->hash_size);
/* Now, adjust ctx->v1 if the old and the new size differ */
if ((size_t)ctx->hash_size != hash_size) {
ctx->v1 ^= 0xee;
- ctx->hash_size = hash_size;
+ ctx->hash_size = (unsigned int)hash_size;
}
return 1;
}
uint64_t k1 = U8TO64_LE(k + 8);
/* If the hash size wasn't set, i.e. is zero */
- ctx->hash_size = siphash_adjust_hash_size(ctx->hash_size);
+ ctx->hash_size = (unsigned int)siphash_adjust_hash_size(ctx->hash_size);
if (drounds == 0)
drounds = SIPHASH_D_ROUNDS;
/* not enough to fill leavings */
if (inlen < available) {
memcpy(&ctx->leavings[ctx->len], in, inlen);
- ctx->len += inlen;
+ ctx->len += (unsigned int)inlen;
return;
}
memcpy(seed + n, pk_seed, n);
return digest_4(hctx->md_big_ctx, r, n, pk_seed, n, pk_root, n, msg, msg_len,
seed + 2 * n)
- && (PKCS1_MGF1(out, m, seed, seed_len, hctx->key->md_big) == 0);
+ && (PKCS1_MGF1(out, (long)m, seed, (long)seed_len, hctx->key->md_big) == 0);
}
static int
if (!WPACKET_allocate_bytes(wpkt, tmp_len, &tmp))
return 0;
- set_hash_address(adrs, j++);
+ set_hash_address(adrs, (uint32_t)(j++));
if (!F(ctx, pk_seed, adrs, in, n, tmp, tmp_len))
return 0;
end_index = start_index + steps;
for (; j < end_index; ++j) {
- set_hash_address(adrs, j);
+ set_hash_address(adrs, (uint32_t)j);
if (!F(ctx, pk_seed, adrs, tmp, n, tmp, tmp_len))
return 0;
}
adrsf->copy_keypair_address(sk_adrs, adrs);
for (i = 0; i < len; ++i) { /* len = 2n + 3 */
- set_chain_address(sk_adrs, i);
+ set_chain_address(sk_adrs, (uint32_t)i);
if (!PRF(ctx, pk_seed, sk_seed, sk_adrs, sk, sizeof(sk)))
goto end;
- set_chain_address(adrs, i);
+ set_chain_address(adrs, (uint32_t)i);
if (!slh_wots_chain(ctx, sk, 0, NIBBLE_MASK, pk_seed, adrs, tmp_wpkt))
goto end;
}
adrsf->copy_keypair_address(sk_adrs, adrs);
for (i = 0; i < len; ++i) {
- set_chain_address(sk_adrs, i);
+ set_chain_address(sk_adrs, (uint32_t)i);
/* compute chain i secret */
if (!PRF(ctx, pk_seed, sk_seed, sk_adrs, sk, sizeof(sk)))
goto err;
- set_chain_address(adrs, i);
+ set_chain_address(adrs, (uint32_t)i);
/* compute chain i signature */
if (!slh_wots_chain(ctx, sk, 0, msg_and_csum_nibbles[i],
pk_seed, adrs, sig_wpkt))
/* Compute the end nodes for each of the chains */
for (i = 0; i < len; ++i) {
- set_chain_address(adrs, i);
+ set_chain_address(adrs, (uint32_t)i);
if (!PACKET_get_bytes(sig_rpkt, &sig_i, n)
|| !slh_wots_chain(ctx, sig_i, msg_and_csum_nibbles[i],
NIBBLE_MASK - msg_and_csum_nibbles[i],
IMPLEMENT_ASN1_FUNCTIONS(SM2_Ciphertext)
-static size_t ec_field_size(const EC_GROUP *group)
+static int ec_field_size(const EC_GROUP *group)
{
const BIGNUM *p = EC_GROUP_get0_field(group);
{
struct SM2_Ciphertext_st *sm2_ctext = NULL;
- sm2_ctext = d2i_SM2_Ciphertext(NULL, &ct, ct_size);
+ sm2_ctext = d2i_SM2_Ciphertext(NULL, &ct, (long)ct_size);
if (sm2_ctext == NULL) {
ERR_raise(ERR_LIB_SM2, SM2_R_INVALID_ENCODING);
int ossl_sm2_ciphertext_size(const EC_KEY *key, const EVP_MD *digest,
size_t msg_len, size_t *ct_size)
{
- const size_t field_size = ec_field_size(EC_KEY_get0_group(key));
+ const int field_size = ec_field_size(EC_KEY_get0_group(key));
const int md_size = EVP_MD_get_size(digest);
- size_t sz;
+ int sz;
- if (field_size == 0 || md_size <= 0)
+ if (field_size == 0 || md_size <= 0 || msg_len > INT_MAX/2)
return 0;
/* Integer and string are simple type; set constructed = 0, means primitive and definite length encoding. */
sz = 2 * ASN1_object_size(0, field_size + 1, V_ASN1_INTEGER)
+ ASN1_object_size(0, md_size, V_ASN1_OCTET_STRING)
- + ASN1_object_size(0, msg_len, V_ASN1_OCTET_STRING);
+ + ASN1_object_size(0, (int)msg_len, V_ASN1_OCTET_STRING);
/* Sequence is structured type; set constructed = 1, means constructed and definite length encoding. */
- *ct_size = ASN1_object_size(1, sz, V_ASN1_SEQUENCE);
+ *ct_size = (size_t)ASN1_object_size(1, sz, V_ASN1_SEQUENCE);
return 1;
}
uint8_t *msg_mask = NULL;
uint8_t *x2y2 = NULL;
uint8_t *C3 = NULL;
- size_t field_size;
+ int field_size;
const int C3_size = EVP_MD_get_size(digest);
EVP_MD *fetched_digest = NULL;
OSSL_LIB_CTX *libctx = ossl_ec_key_get_libctx(key);
ctext_struct.C2 = NULL;
ctext_struct.C3 = NULL;
+ if (msg_len > INT_MAX/2) {
+ ERR_raise(ERR_LIB_SM2, ERR_R_PASSED_INVALID_ARGUMENT);
+ goto done;
+ }
+
if (hash == NULL || C3_size <= 0) {
ERR_raise(ERR_LIB_SM2, ERR_R_INTERNAL_ERROR);
goto done;
goto done;
}
if (!ASN1_OCTET_STRING_set(ctext_struct.C3, C3, C3_size)
- || !ASN1_OCTET_STRING_set(ctext_struct.C2, msg_mask, msg_len)) {
+ || !ASN1_OCTET_STRING_set(ctext_struct.C2, msg_mask, (int)msg_len)) {
ERR_raise(ERR_LIB_SM2, ERR_R_INTERNAL_ERROR);
goto done;
}
BIGNUM *y2 = NULL;
uint8_t *x2y2 = NULL;
uint8_t *computed_C3 = NULL;
- const size_t field_size = ec_field_size(group);
+ const int field_size = ec_field_size(group);
const int hash_size = EVP_MD_get_size(digest);
uint8_t *msg_mask = NULL;
const uint8_t *C2 = NULL;
OSSL_LIB_CTX *libctx = ossl_ec_key_get_libctx(key);
const char *propq = ossl_ec_key_get0_propq(key);
- if (field_size == 0 || hash_size <= 0)
+ if (field_size == 0 || hash_size <= 0 || ciphertext_len > LONG_MAX)
goto done;
memset(ptext_buf, 0xFF, *ptext_len);
- sm2_ctext = d2i_SM2_Ciphertext(NULL, &ciphertext, ciphertext_len);
+ sm2_ctext = d2i_SM2_Ciphertext(NULL, &ciphertext, (long)ciphertext_len);
if (sm2_ctext == NULL) {
ERR_raise(ERR_LIB_SM2, SM2_R_ASN1_ERROR);
/* Add any encoded padding that is required */
if (padsize != 0
- && EVP_DecodeUpdate(ctx, a, &outl, pad, padsize) < 0) {
+ && EVP_DecodeUpdate(ctx, a, &outl, pad, (int)padsize) < 0) {
outl = -1;
goto err;
}
- if (EVP_DecodeUpdate(ctx, a, &outl2, (const unsigned char *)src, size) < 0) {
+ if (EVP_DecodeUpdate(ctx, a, &outl2, (const unsigned char *)src, (int)size) < 0) {
outl = -1;
goto err;
}
* from the encoded data as we added to the pre-encoded data.
*/
memmove(a, a + padsize, outl - padsize);
- outl -= padsize;
+ outl -= (int)padsize;
}
err:
EVP_ENCODE_CTX *ctx = EVP_ENCODE_CTX_new();
int outl = 0, outl2 = 0;
unsigned char pad[2] = {0, 0};
- size_t leadz = 0;
+ int leadz = 0;
if (ctx == NULL)
return 0;
* No need to check the returned value, |new_der|
* will be NULL on error anyway.
*/
- PKCS12_pbe_crypt(alg, pbuf, plen,
+ PKCS12_pbe_crypt(alg, pbuf, (int)plen,
oct->data, oct->length,
&new_der, &len, 0);
der_len = len;
ignore_trusted = 0;
if (d2i_X509_AUX(&cert, (const unsigned char **)&data->octet_data,
- data->octet_data_size) == NULL
+ (long)data->octet_data_size) == NULL
&& (!ignore_trusted
|| d2i_X509(&cert, (const unsigned char **)&data->octet_data,
- data->octet_data_size) == NULL)) {
+ (long)data->octet_data_size) == NULL)) {
X509_free(cert);
cert = NULL;
}
X509_CRL *crl;
crl = d2i_X509_CRL(NULL, (const unsigned char **)&data->octet_data,
- data->octet_data_size);
+ (long)data->octet_data_size);
if (crl != NULL)
/* We determined the object type */
PKCS12 *p12;
p12 = d2i_PKCS12(NULL, (const unsigned char **)&data->octet_data,
- data->octet_data_size);
+ (long)data->octet_data_size);
if (p12 != NULL) {
char *pass = NULL;
* we must do it for PKCS12_parse()
*/
pass[tpass_len] = '\0';
- if (!PKCS12_verify_mac(p12, pass, tpass_len)) {
+ if (!PKCS12_verify_mac(p12, pass, (int)tpass_len)) {
ERR_raise_data(ERR_LIB_OSSL_STORE,
OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC,
tpass_len == 0 ? "empty password" :
cv->closed = 1;
ossl_crypto_mutex_unlock(cv->int_m);
- ReleaseSemaphore(cv->sema, num_wake, NULL);
+ ReleaseSemaphore(cv->sema, (LONG)num_wake, NULL);
}
void ossl_crypto_condvar_signal(CRYPTO_CONDVAR *cv_)
break;
case CALLBACK_CHANNEL:
(void)BIO_ctrl(channel, OSSL_TRACE_CTRL_BEGIN,
- prefix == NULL ? 0 : strlen(prefix), prefix);
+ prefix == NULL ? 0 : (int)strlen(prefix), prefix);
break;
}
}
break;
case CALLBACK_CHANNEL:
(void)BIO_ctrl(channel, OSSL_TRACE_CTRL_END,
- suffix == NULL ? 0 : strlen(suffix), suffix);
+ suffix == NULL ? 0 : (int)strlen(suffix), suffix);
break;
}
current_channel = NULL;
return -1;
if ((hex = BN_bn2hex(num_bn))) {
result = BIO_write(bio, "0x", 2) > 0;
- result = result && BIO_write(bio, hex, strlen(hex)) > 0;
+ result = result && BIO_write(bio, hex, (int)strlen(hex)) > 0;
OPENSSL_free(hex);
}
BN_free(num_bn);
}
if (text) {
if ((utf8_text = ASN1_UTF8STRING_new()) == NULL
- || !ASN1_STRING_set(utf8_text, text, strlen(text))) {
+ || !ASN1_STRING_set(utf8_text, text, (int)strlen(text))) {
ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
goto err;
}
break;
if ((offset == 0) && (buf->data[0] == '#'))
continue;
- i = strlen(&(buf->data[offset]));
+ i = (int)strlen(&(buf->data[offset]));
offset += i;
if (buf->data[offset - 1] != '\n')
continue;
l = 0;
for (j = 0; j < nn; j++) {
if (pp[j] != NULL)
- l += strlen(pp[j]);
+ l += (long)strlen(pp[j]);
}
if (!BUF_MEM_grow_clean(buf, (int)(l * 2 + nn)))
goto err;
*(p++) = '\t';
}
p[-1] = '\n';
- j = p - buf->data;
+ j = (long)(p - buf->data);
if (BIO_write(out, buf->data, (int)j) != j)
goto err;
tot += j;
if (phrase_desc == NULL)
return NULL;
- len = sizeof(prompt1) - 1 + strlen(phrase_desc);
+ len = sizeof(prompt1) - 1 + (int)strlen(phrase_desc);
if (object_name != NULL)
- len += sizeof(prompt2) - 1 + strlen(object_name);
+ len += sizeof(prompt2) - 1 + (int)strlen(object_name);
len += sizeof(prompt3) - 1;
if ((prompt = OPENSSL_malloc(len + 1)) == NULL)
switch (uis->type) {
case UIT_PROMPT:
case UIT_VERIFY:
- return uis->result_len;
+ return (int)uis->result_len;
case UIT_NONE:
case UIT_BOOLEAN:
case UIT_INFO:
int UI_set_result(UI *ui, UI_STRING *uis, const char *result)
{
- return UI_set_result_ex(ui, uis, result, strlen(result));
+ return UI_set_result_ex(ui, uis, result, (int)strlen(result));
}
int UI_set_result_ex(UI *ui, UI_STRING *uis, const char *result, int len)
BY_DIR_HASH htmp, *hent;
ent = sk_BY_DIR_ENTRY_value(ctx->dirs, i);
- j = strlen(ent->dir) + 1 + 8 + 6 + 1 + 1;
+ j = (int)strlen(ent->dir) + 1 + 8 + 6 + 1 + 1;
if (!BUF_MEM_grow(b, j)) {
ERR_raise(ERR_LIB_X509, ERR_R_BUF_LIB);
goto finish;
continue;
}
- i1 = strspn(s, addr_chars);
- i2 = i1 + strspn(s + i1, " \t");
+ i1 = (int)strspn(s, addr_chars);
+ i2 = i1 + (int)strspn(s + i1, " \t");
delim = s[i2++];
s[i1] = '\0';
}
break;
case '-':
- i1 = i2 + strspn(s + i2, " \t");
- i2 = i1 + strspn(s + i1, addr_chars);
+ i1 = i2 + (int)strspn(s + i2, " \t");
+ i2 = i1 + (int)strspn(s + i1, addr_chars);
if (i1 == i2 || s[i2] != '\0') {
ERR_raise(ERR_LIB_X509V3, X509V3_R_EXTENSION_VALUE_ERROR);
X509V3_conf_add_error_name_value(val);
/*
* Number, range, or mistake, pick it apart and figure out which.
*/
- i1 = strspn(val->value, "0123456789");
+ i1 = (int)strspn(val->value, "0123456789");
if (val->value[i1] == '\0') {
is_range = 0;
} else {
is_range = 1;
- i2 = i1 + strspn(val->value + i1, " \t");
+ i2 = i1 + (int)strspn(val->value + i1, " \t");
if (val->value[i2] != '-') {
ERR_raise(ERR_LIB_X509V3, X509V3_R_INVALID_ASNUMBER);
X509V3_conf_add_error_name_value(val);
goto err;
}
i2++;
- i2 = i2 + strspn(val->value + i2, " \t");
- i3 = i2 + strspn(val->value + i2, "0123456789");
+ i2 = i2 + (int)strspn(val->value + i2, " \t");
+ i3 = i2 + (int)strspn(val->value + i2, "0123456789");
if (val->value[i3] != '\0') {
ERR_raise(ERR_LIB_X509V3, X509V3_R_INVALID_ASRANGE);
X509V3_conf_add_error_name_value(val);
goto err;
}
if (!ASN1_STRING_set(qual->d.cpsuri, cnf->value,
- strlen(cnf->value))) {
+ (int)strlen(cnf->value))) {
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
{
char *colon = strchr(tagstr, ':');
- return (colon == NULL) ? -1 : colon - tagstr;
+ return (colon == NULL) ? -1 : (int)(colon - tagstr);
}
static int displaytext_str2tag(const char *tagstr, unsigned int *tag_len)
}
if (tag_len != 0)
value += tag_len + 1;
- len = strlen(value);
+ len = (int)strlen(value);
if (!ASN1_STRING_set(not->exptext, value, len)) {
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
else
nref->organization->type = V_ASN1_VISIBLESTRING;
if (!ASN1_STRING_set(nref->organization, cnf->value,
- strlen(cnf->value))) {
+ (int)strlen(cnf->value))) {
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
- if (!ASN1_STRING_set((ASN1_STRING *)ia5, str, strlen(str))) {
+ if (!ASN1_STRING_set((ASN1_STRING *)ia5, str, (int)strlen(str))) {
ASN1_IA5STRING_free(ia5);
return NULL;
}
STACK_OF(CONF_VALUE) *ret)
{
ACCESS_DESCRIPTION *desc;
- int i, nlen;
+ int i;
+ size_t nlen;
char objtmp[80], *ntmp;
CONF_VALUE *vtmp;
STACK_OF(CONF_VALUE) *tret = ret;
ist->signTool = ASN1_UTF8STRING_new();
if (ist->signTool == NULL
|| cnf->value == NULL
- || !ASN1_STRING_set(ist->signTool, cnf->value, strlen(cnf->value))) {
+ || !ASN1_STRING_set(ist->signTool, cnf->value, (int)strlen(cnf->value))) {
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
ist->cATool = ASN1_UTF8STRING_new();
if (ist->cATool == NULL
|| cnf->value == NULL
- || !ASN1_STRING_set(ist->cATool, cnf->value, strlen(cnf->value))) {
+ || !ASN1_STRING_set(ist->cATool, cnf->value, (int)strlen(cnf->value))) {
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
ist->signToolCert = ASN1_UTF8STRING_new();
if (ist->signToolCert == NULL
|| cnf->value == NULL
- || !ASN1_STRING_set(ist->signToolCert, cnf->value, strlen(cnf->value))) {
+ || !ASN1_STRING_set(ist->signToolCert, cnf->value, (int)strlen(cnf->value))) {
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
ist->cAToolCert = ASN1_UTF8STRING_new();
if (ist->cAToolCert == NULL
|| cnf->value == NULL
- || !ASN1_STRING_set(ist->cAToolCert, cnf->value, strlen(cnf->value))) {
+ || !ASN1_STRING_set(ist->cAToolCert, cnf->value, (int)strlen(cnf->value))) {
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
if (idlen == 0)
continue;
- stmp.length = idlen;
+ stmp.length = (int)idlen;
stmp.data = idval;
r = nc_match(&gntmp, nc);
OPENSSL_free(idval);
OPENSSL_free(scheme);
OPENSSL_free(uri_copy);
- hostlen = strlen(host);
+ hostlen = (int)strlen(host);
/* Special case: initial '.' is RHS match */
if (base->length > 0 && *baseptr == '.') {
goto err;
}
} else if (CHECK_AND_SKIP_PREFIX(valp, "text:")) {
- val_len = strlen(valp);
+ val_len = (int)strlen(valp);
tmp_data = OPENSSL_realloc((*policy)->data,
(*policy)->length + val_len + 1);
if (tmp_data) {
if (is_string) {
if ((gen->d.ia5 = ASN1_IA5STRING_new()) == NULL ||
!ASN1_STRING_set(gen->d.ia5, (unsigned char *)value,
- strlen(value))) {
+ (int)strlen(value))) {
ASN1_IA5STRING_free(gen->d.ia5);
gen->d.ia5 = NULL;
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
static int do_othername(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx)
{
char *objtmp = NULL, *p;
- int objlen;
+ size_t objlen;
if ((p = strchr(value, ';')) == NULL)
return 0;
return 0;
}
if (userlen == -1)
- userlen = strlen(user);
+ userlen = (int)strlen(user);
if (userlen > 64) {
ERR_raise(ERR_LIB_X509V3, X509V3_R_USER_TOO_LONG);
return 0;
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
- if (!ASN1_STRING_set((ASN1_STRING *)utf8, str, strlen(str))) {
+ if (!ASN1_STRING_set((ASN1_STRING *)utf8, str, (int)strlen(str))) {
ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
ASN1_UTF8STRING_free(utf8);
return NULL;
int ossl_v3_name_cmp(const char *name, const char *cmp)
{
- int len, ret;
+ size_t len;
+ int ret;
char c;
len = strlen(cmp);
ret = X509_ACERT_add1_attr_by_txt(acert, v->name,
V_ASN1_OCTET_STRING,
(unsigned char *)value,
- strlen(value));
+ (int)strlen(value));
if (!ret)
goto err;
}
i2t_ASN1_OBJECT(tmp_buf, sizeof(tmp_buf), ne->object);
s = tmp_buf;
}
- l1 = strlen(s);
+ l1 = (int)strlen(s);
type = ne->value->type;
num = ne->value->length;
size_t iplen;
unsigned char *ip = int_X509_VERIFY_PARAM_get0_ip(param, &iplen);
- return ip == NULL ? NULL : ossl_ipaddr_to_asc(ip, iplen);
+ return ip == NULL ? NULL : ossl_ipaddr_to_asc(ip, (int)iplen);
}
int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param,
len, type,
OBJ_obj2nid(ne->object)) ? 1 : 0;
if (len < 0)
- len = strlen((const char *)bytes);
+ len = (int)strlen((const char *)bytes);
i = ASN1_STRING_set(ne->value, bytes, len);
if (!i)
return 0;
int spki_len;
NETSCAPE_SPKI *spki;
if (len <= 0)
- len = strlen(str);
+ len = (int)strlen(str);
if ((spki_der = OPENSSL_malloc(len + 1)) == NULL)
return NULL;
spki_len = EVP_DecodeBlock(spki_der, (const unsigned char *)str, len);
if (!ret)
return -1;
}
- ret = a->bytes->length;
+ ret = (int)a->bytes->length;
if (out != NULL) {
memcpy(*out, a->bytes->data, ret);
*out += ret;
}
}
- out->length = to - out->data;
+ out->length = (int)(to - out->data);
return 1;
(ossl_isupper(s[2]) && (s[3] == '='))
))) || (*s == '\0'))
{
- i = s - c;
+ i = (int)(s - c);
if (BIO_write(bp, c, i) != i)
goto err;
c = s + 1; /* skip following slash */
&& out != NULL
&& OSSL_ENCODER_to_bio(ctx, out)
&& BIO_get_mem_ptr(out, &buf) > 0) {
- ret = buf->length;
+ ret = (int)buf->length;
if (pp != NULL) {
if (*pp == NULL) {
if (ret == NULL)
return NULL;
/* update length */
- length -= q - *pp;
+ length -= (long)(q - *pp);
if (length > 0 && !d2i_X509_CERT_AUX(&ret->aux, &q, length))
goto err;
*pp = q;
#endif
int ossl_bn_mont_ctx_set(BN_MONT_CTX *ctx, const BIGNUM *modulus, int ri,
- const unsigned char *rr, size_t rrlen,
+ const unsigned char *rr, int rrlen,
uint32_t nlo, uint32_t nhi);
int ossl_bn_mont_ctx_eq(const BN_MONT_CTX *m1, const BN_MONT_CTX *m2);
/* Same as HT_SET_KEY_STRING_CASE but also takes length of the string. */
#define HT_SET_KEY_STRING_CASE_N(key, member, value, len) do { \
- if (len < sizeof((key)->keyfields.member)) \
+ if ((size_t)len < sizeof((key)->keyfields.member)) \
ossl_ht_strcase((key)->keyfields.member, value, len); \
else \
ossl_ht_strcase((key)->keyfields.member, value, sizeof((key)->keyfields.member) - 1); \
int ossl_namemap_name2num_n(const OSSL_NAMEMAP *namemap,
const char *name, size_t name_len);
const char *ossl_namemap_num2name(const OSSL_NAMEMAP *namemap, int number,
- size_t idx);
+ int idx);
int ossl_namemap_doall_names(const OSSL_NAMEMAP *namemap, int number,
void (*fn)(const char *name, void *data),
void *data);
*/
static ossl_unused ossl_inline size_t ossl_quic_vlint_decode_len(uint8_t first_byte)
{
- return 1U << ((first_byte & 0xC0) >> 6);
+ return (size_t)(1U << ((first_byte & 0xC0) >> 6));
}
/*
# define _InterlockedExchangeAdd64 _InterlockedExchangeAdd64_nf
# pragma intrinsic(_InterlockedExchangeAdd64_nf)
# pragma intrinsic(__iso_volatile_load64, __iso_volatile_store64)
-# define tsan_load(ptr) (sizeof(*(ptr)) == 8 ? __iso_volatile_load64(ptr) \
- : __iso_volatile_load32(ptr))
-# define tsan_store(ptr, val) (sizeof(*(ptr)) == 8 ? __iso_volatile_store64((ptr), (val)) \
- : __iso_volatile_store32((ptr), (val)))
+# define tsan_load(ptr) (sizeof(*(ptr)) == 8 ? __iso_volatile_load64((void *)(ptr)) \
+ : __iso_volatile_load32((void *)(ptr)))
+# define tsan_store(ptr, val) (sizeof(*(ptr)) == 8 ? __iso_volatile_store64(((void *)(ptr)), (val)) \
+ : __iso_volatile_store32((void *)(ptr), (val)))
# else
# define tsan_load(ptr) __iso_volatile_load32(ptr)
# define tsan_store(ptr, val) __iso_volatile_store32((ptr), (val))
# pragma intrinsic(_InterlockedExchangeAdd)
# ifdef _WIN64
# pragma intrinsic(_InterlockedExchangeAdd64)
-# define tsan_add(ptr, n) (sizeof(*(ptr)) == 8 ? _InterlockedExchangeAdd64((ptr), (n)) \
- : _InterlockedExchangeAdd((ptr), (n)))
+# define tsan_add(ptr, n) (sizeof(*(ptr)) == 8 ? _InterlockedExchangeAdd64((void *)(ptr), (n)) \
+ : _InterlockedExchangeAdd((void *)(ptr), (n)))
# else
# define tsan_add(ptr, n) _InterlockedExchangeAdd((ptr), (n))
# endif
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
+#include <stddef.h>
#include "uplink.h"
void OPENSSL_showfatal(const char *, ...);
} else
p = applinktable;
- if (index > (int)p[0])
+ if (index > (intptr_t)p[0])
break;
if (p[index])
projects / thirdparty / openssl.git / commitdiff
