ssl_minor = *(p++);
version = (ssl_major << 8) | ssl_minor;
rr[num_recs].rec_version = version;
- /* TODO(size_t): CHECK ME */
n2s(p, rr[num_recs].length);
/* Lets check version */
rr[j].length -= mac_size;
mac = rr[j].data + rr[j].length;
i = s->method->ssl3_enc->mac(s, &rr[j], md, 0 /* not send */ );
- if (i < 0 || CRYPTO_memcmp(md, mac, mac_size) != 0) {
+ if (i == 0 || CRYPTO_memcmp(md, mac, mac_size) != 0) {
al = SSL_AD_BAD_RECORD_MAC;
SSLerr(SSL_F_SSL3_GET_RECORD,
SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
}
i = s->method->ssl3_enc->mac(s, &rr[j], md, 0 /* not send */ );
- if (i < 0 || mac == NULL
+ if (i == 0 || mac == NULL
|| CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
enc_err = -1;
if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
/* COMPRESS */
if ((bs != 1) && send) {
- i = bs - ((int)l % bs);
+ i = bs - (l % bs);
/* we need to add 'i-1' padding bytes */
l += i;
*/
memset(&rec->input[rec->length], 0, i);
rec->length += i;
- rec->input[l - 1] = (i - 1);
+ rec->input[l - 1] = (unsigned char)(i - 1);
}
if (!send) {
}
/* TODO(size_t): Convert this call */
- if (EVP_Cipher(ds, rec->data, rec->input, l) < 1)
+ if (EVP_Cipher(ds, rec->data, rec->input, (unsigned int)l) < 1)
return -1;
if (EVP_MD_CTX_md(s->read_hash) != NULL) {
buf[ctr][8] = recs[ctr].type;
buf[ctr][9] = (unsigned char)(s->version >> 8);
buf[ctr][10] = (unsigned char)(s->version);
- buf[ctr][11] = recs[ctr].length >> 8;
- buf[ctr][12] = recs[ctr].length & 0xff;
+ buf[ctr][11] = (unsigned char)(recs[ctr].length >> 8);
+ buf[ctr][12] = (unsigned char)(recs[ctr].length & 0xff);
pad = EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_AEAD_TLS1_AAD,
EVP_AEAD_TLS1_AAD_LEN, buf[ctr]);
if (pad <= 0)
}
} else if ((bs != 1) && send) {
- padnum = bs - ((int)reclen[ctr] % bs);
+ padnum = bs - (reclen[ctr] % bs);
/* Add weird padding of upto 256 bytes */
if (padnum > MAX_PADDING)
return -1;
/* we need to add 'padnum' padding bytes of value padval */
- padval = padnum - 1;
+ padval = (unsigned char)(padnum - 1);
for (loop = reclen[ctr]; loop < reclen[ctr] + padnum; loop++)
recs[ctr].input[loop] = padval;
reclen[ctr] += padnum;
data[ctr] = recs[ctr].data;
}
if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS,
- n_recs, data) <= 0) {
+ (int)n_recs, data) <= 0) {
SSLerr(SSL_F_TLS1_ENC, SSL_R_PIPELINE_FAILURE);
}
/* Set the input buffers */
data[ctr] = recs[ctr].input;
}
if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_BUFS,
- n_recs, data) <= 0
+ (int)n_recs, data) <= 0
|| EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_LENS,
- n_recs, reclen) <= 0) {
+ (int)n_recs, reclen) <= 0) {
SSLerr(SSL_F_TLS1_ENC, SSL_R_PIPELINE_FAILURE);
return -1;
}
}
- tmpr = EVP_Cipher(ds, recs[0].data, recs[0].input, reclen[0]);
+ /* TODO(size_t): Convert this call */
+ tmpr = EVP_Cipher(ds, recs[0].data, recs[0].input,
+ (unsigned int)reclen[0]);
if ((EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ds))
& EVP_CIPH_FLAG_CUSTOM_CIPHER)
? (tmpr < 0)
const EVP_MD_CTX *hash;
unsigned char *p, rec_char;
size_t md_size;
- int npad;
+ size_t npad;
int t;
if (send) {
t = EVP_MD_CTX_size(hash);
if (t < 0)
- return -1;
+ return 0;
md_size = t;
npad = (48 / md_size) * md_size;
* total size.
*/
unsigned char header[75];
- unsigned j = 0;
+ size_t j = 0;
memcpy(header + j, mac_sec, md_size);
j += md_size;
memcpy(header + j, ssl3_pad_1, npad);
memcpy(header + j, seq, 8);
j += 8;
header[j++] = rec->type;
- header[j++] = rec->length >> 8;
- header[j++] = rec->length & 0xff;
+ header[j++] = (unsigned char)(rec->length >> 8);
+ header[j++] = (unsigned char)(rec->length & 0xff);
/* Final param == is SSLv3 */
if (ssl3_cbc_digest_record(hash,
header, rec->input,
rec->length + md_size, rec->orig_len,
mac_sec, md_size, 1) <= 0)
- return -1;
+ return 0;
} else {
unsigned int md_size_u;
/* Chop the digest off the end :-) */
EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
if (md_ctx == NULL)
- return -1;
+ return 0;
rec_char = rec->type;
p = md;
|| EVP_DigestUpdate(md_ctx, md, md_size) <= 0
|| EVP_DigestFinal_ex(md_ctx, md, &md_size_u) <= 0) {
EVP_MD_CTX_reset(md_ctx);
- return -1;
+ return 0;
}
- md_size = md_size_u;
EVP_MD_CTX_free(md_ctx);
}
ssl3_record_sequence_update(seq);
- return (md_size);
+ return 1;
}
int tls1_mac(SSL *ssl, SSL3_RECORD *rec, unsigned char *md, int send)
} else {
hmac = EVP_MD_CTX_new();
if (hmac == NULL || !EVP_MD_CTX_copy(hmac, hash))
- return -1;
+ return 0;
mac_ctx = hmac;
}
header[8] = rec->type;
header[9] = (unsigned char)(ssl->version >> 8);
header[10] = (unsigned char)(ssl->version);
- header[11] = (rec->length) >> 8;
- header[12] = (rec->length) & 0xff;
+ header[11] = (unsigned char)(rec->length >> 8);
+ header[12] = (unsigned char)(rec->length & 0xff);
if (!send && !SSL_USE_ETM(ssl) &&
EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
* are hashing because that gives an attacker a timing-oracle.
*/
/* Final param == not SSLv3 */
- /* TODO(size_t): Convert this call */
if (ssl3_cbc_digest_record(mac_ctx,
md, &md_size,
header, rec->input,
|| EVP_DigestSignUpdate(mac_ctx, rec->input, rec->length) <= 0
|| EVP_DigestSignFinal(mac_ctx, md, &md_size) <= 0) {
EVP_MD_CTX_free(hmac);
- return -1;
+ return 0;
}
if (!send && !SSL_USE_ETM(ssl) && FIPS_mode())
if (!tls_fips_digest_extra(ssl->enc_read_ctx,
mac_ctx, rec->input,
rec->length, rec->orig_len)) {
EVP_MD_CTX_free(hmac);
- return -1;
+ return 0;
}
}
fprintf(stderr, "\n");
}
#endif
- return (md_size);
+ return 1;
}
/*-
* 1: if the padding was valid
* -1: otherwise.
*/
- /* TODO(size_t): Convert me */
int ssl3_cbc_remove_padding(SSL3_RECORD *rec,
size_t block_size, size_t mac_size)
{
size_t padding_length;
- unsigned good;
+ size_t good;
const size_t overhead = 1 /* padding length byte */ + mac_size;
/*
return 0;
padding_length = rec->data[rec->length - 1];
- /* TODO(size_t): size_t constant_time ? */
- good = constant_time_ge(rec->length, padding_length + overhead);
+ good = constant_time_ge_s(rec->length, padding_length + overhead);
/* SSLv3 requires that the padding is minimal. */
- good &= constant_time_ge(block_size, padding_length + 1);
+ good &= constant_time_ge_s(block_size, padding_length + 1);
rec->length -= good & (padding_length + 1);
- return constant_time_select_int(good, 1, -1);
+ return constant_time_select_int_s(good, 1, -1);
}
/*-
SSL3_RECORD *rec,
size_t block_size, size_t mac_size)
{
- unsigned good;
+ size_t good;
size_t padding_length, to_check, i;
const size_t overhead = 1 /* padding length byte */ + mac_size;
/* Check if version requires explicit IV */
return 1;
}
- /* TODO(size_t): size_t constant_time?? */
- good = constant_time_ge(rec->length, overhead + padding_length);
+ good = constant_time_ge_s(rec->length, overhead + padding_length);
/*
* The padding consists of a length byte at the end of the record and
* then that many bytes of padding, all with the same value as the length
to_check = rec->length;
for (i = 0; i < to_check; i++) {
- unsigned char mask = constant_time_ge_8(padding_length, i);
+ unsigned char mask = constant_time_ge_8_s(padding_length, i);
unsigned char b = rec->data[rec->length - 1 - i];
/*
* The final |padding_length+1| bytes should all have the value
* If any of the final |padding_length+1| bytes had the wrong value, one
* or more of the lower eight bits of |good| will be cleared.
*/
- good = constant_time_eq(0xff, good & 0xff);
+ good = constant_time_eq_s(0xff, good & 0xff);
rec->length -= good & (padding_length + 1);
- return constant_time_select_int(good, 1, -1);
+ return constant_time_select_int_s(good, 1, -1);
}
/*-
* MAC's position can only vary by 255 bytes.
*/
size_t scan_start = 0;
- unsigned i, j;
- unsigned div_spoiler;
- unsigned rotate_offset;
+ size_t i, j;
+ size_t div_spoiler;
+ size_t rotate_offset;
OPENSSL_assert(rec->orig_len >= md_size);
OPENSSL_assert(md_size <= EVP_MAX_MD_SIZE);
memset(rotated_mac, 0, md_size);
for (i = scan_start, j = 0; i < rec->orig_len; i++) {
- /* TODO(size_t): should we have constant_time variants for size_t? */
- unsigned char mac_started = constant_time_ge_8(i, mac_start);
- unsigned char mac_ended = constant_time_ge_8(i, mac_end);
+ unsigned char mac_started = constant_time_ge_8_s(i, mac_start);
+ unsigned char mac_ended = constant_time_ge_8_s(i, mac_end);
unsigned char b = rec->data[i];
rotated_mac[j++] |= b & mac_started & ~mac_ended;
- j &= constant_time_lt(j, md_size);
+ j &= constant_time_lt_s(j, md_size);
}
/* Now rotate the MAC */
/* in case cache-line is 32 bytes, touch second line */
((volatile unsigned char *)rotated_mac)[rotate_offset ^ 32];
out[j++] = rotated_mac[rotate_offset++];
- rotate_offset &= constant_time_lt(rotate_offset, md_size);
+ rotate_offset &= constant_time_lt_s(rotate_offset, md_size);
}
#else
memset(out, 0, md_size);
rotate_offset = md_size - rotate_offset;
- rotate_offset &= constant_time_lt(rotate_offset, md_size);
+ rotate_offset &= constant_time_lt_s(rotate_offset, md_size);
for (i = 0; i < md_size; i++) {
for (j = 0; j < md_size; j++)
- out[j] |= rotated_mac[i] & constant_time_eq_8(j, rotate_offset);
+ out[j] |= rotated_mac[i] & constant_time_eq_8_s(j, rotate_offset);
rotate_offset++;
- rotate_offset &= constant_time_lt(rotate_offset, md_size);
+ rotate_offset &= constant_time_lt_s(rotate_offset, md_size);
}
#endif
}
rr->length -= mac_size;
mac = rr->data + rr->length;
i = s->method->ssl3_enc->mac(s, rr, md, 0 /* not send */ );
- if (i < 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) {
+ if (i == 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) {
al = SSL_AD_BAD_RECORD_MAC;
SSLerr(SSL_F_DTLS1_PROCESS_RECORD,
SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
}
i = s->method->ssl3_enc->mac(s, rr, md, 0 /* not send */ );
- if (i < 0 || mac == NULL
+ if (i == 0 || mac == NULL
|| CRYPTO_memcmp(md, mac, mac_size) != 0)
enc_err = -1;
if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
memcpy(&(RECORD_LAYER_get_read_sequence(&s->rlayer)[2]), p, 6);
p += 6;
- /* TODO(size_t): CHECK ME */
n2s(p, rr->length);
/* Lets check version */
projects / openssl.git / blobdiff