Work around language and compiler bug in memcpy, etc.
Most C standard library functions are undefined if passed NULL, even
when the corresponding length is zero. This gives them (and, in turn,
all functions which call them) surprising behavior on empty arrays.
Some compilers will miscompile code due to this rule. See also
https://www.imperialviolet.org/2016/06/26/nonnull.html
Add OPENSSL_memcpy, etc., wrappers which avoid this problem.
BUG=23
Change-Id: I95f42b23e92945af0e681264fffaf578e7f8465e
Reviewed-on: https://boringssl-review.googlesource.com/12928
Commit-Queue: David Benjamin <davidben@google.com>
Reviewed-by: Adam Langley <agl@google.com>
diff --git a/ssl/d1_both.c b/ssl/d1_both.c
index f9bb8f4..d3e4a92 100644
--- a/ssl/d1_both.c
+++ b/ssl/d1_both.c
@@ -124,6 +124,7 @@
#include <openssl/rand.h>
#include <openssl/x509.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -157,7 +158,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
return NULL;
}
- memset(frag, 0, sizeof(hm_fragment));
+ OPENSSL_memset(frag, 0, sizeof(hm_fragment));
frag->type = msg_hdr->type;
frag->seq = msg_hdr->seq;
frag->msg_len = msg_hdr->msg_len;
@@ -195,7 +196,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
goto err;
}
- memset(frag->reassembly, 0, bitmask_len);
+ OPENSSL_memset(frag->reassembly, 0, bitmask_len);
}
return frag;
@@ -383,7 +384,7 @@
assert(msg_len > 0);
/* Copy the body into the fragment. */
- memcpy(frag->data + DTLS1_HM_HEADER_LENGTH + frag_off, CBS_data(&body),
+ OPENSSL_memcpy(frag->data + DTLS1_HM_HEADER_LENGTH + frag_off, CBS_data(&body),
CBS_len(&body));
dtls1_hm_fragment_mark(frag, frag_off, frag_off + frag_len);
}
@@ -489,7 +490,7 @@
int dtls1_parse_fragment(CBS *cbs, struct hm_header_st *out_hdr,
CBS *out_body) {
- memset(out_hdr, 0x00, sizeof(struct hm_header_st));
+ OPENSSL_memset(out_hdr, 0x00, sizeof(struct hm_header_st));
if (!CBS_get_u8(cbs, &out_hdr->type) ||
!CBS_get_u24(cbs, &out_hdr->msg_len) ||
@@ -747,7 +748,7 @@
/* Fix up the header. Copy the fragment length into the total message
* length. */
- memcpy(*out_msg + 1, *out_msg + DTLS1_HM_HEADER_LENGTH - 3, 3);
+ OPENSSL_memcpy(*out_msg + 1, *out_msg + DTLS1_HM_HEADER_LENGTH - 3, 3);
return 1;
}
diff --git a/ssl/d1_lib.c b/ssl/d1_lib.c
index cafb4c2..ba3c844 100644
--- a/ssl/d1_lib.c
+++ b/ssl/d1_lib.c
@@ -64,9 +64,11 @@
#include <openssl/mem.h>
#include <openssl/nid.h>
+#include "../crypto/internal.h"
#include "internal.h"
+
/* DTLS1_MTU_TIMEOUTS is the maximum number of timeouts to expire
* before starting to decrease the MTU. */
#define DTLS1_MTU_TIMEOUTS 2
@@ -86,7 +88,7 @@
ssl3_free(ssl);
return 0;
}
- memset(d1, 0, sizeof *d1);
+ OPENSSL_memset(d1, 0, sizeof *d1);
ssl->d1 = d1;
@@ -154,12 +156,12 @@
if (ssl->d1->next_timeout.tv_sec < timenow.tv_sec ||
(ssl->d1->next_timeout.tv_sec == timenow.tv_sec &&
ssl->d1->next_timeout.tv_usec <= timenow.tv_usec)) {
- memset(out, 0, sizeof(struct timeval));
+ OPENSSL_memset(out, 0, sizeof(struct timeval));
return 1;
}
/* Calculate time left until timer expires */
- memcpy(out, &ssl->d1->next_timeout, sizeof(struct timeval));
+ OPENSSL_memcpy(out, &ssl->d1->next_timeout, sizeof(struct timeval));
out->tv_sec -= timenow.tv_sec;
out->tv_usec -= timenow.tv_usec;
if (out->tv_usec < 0) {
@@ -170,7 +172,7 @@
/* If remaining time is less than 15 ms, set it to 0 to prevent issues
* because of small devergences with socket timeouts. */
if (out->tv_sec == 0 && out->tv_usec < 15000) {
- memset(out, 0, sizeof(struct timeval));
+ OPENSSL_memset(out, 0, sizeof(struct timeval));
}
return 1;
@@ -204,7 +206,7 @@
void dtls1_stop_timer(SSL *ssl) {
/* Reset everything */
ssl->d1->num_timeouts = 0;
- memset(&ssl->d1->next_timeout, 0, sizeof(struct timeval));
+ OPENSSL_memset(&ssl->d1->next_timeout, 0, sizeof(struct timeval));
ssl->d1->timeout_duration_ms = ssl->initial_timeout_duration_ms;
BIO_ctrl(ssl->rbio, BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0,
&ssl->d1->next_timeout);
diff --git a/ssl/d1_pkt.c b/ssl/d1_pkt.c
index 155359c..c6950d5 100644
--- a/ssl/d1_pkt.c
+++ b/ssl/d1_pkt.c
@@ -122,6 +122,7 @@
#include <openssl/err.h>
#include <openssl/rand.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -265,7 +266,7 @@
len = rr->length;
}
- memcpy(buf, rr->data, len);
+ OPENSSL_memcpy(buf, rr->data, len);
if (!peek) {
/* TODO(davidben): Should the record be truncated instead? This is a
* datagram transport. See https://crbug.com/boringssl/65. */
diff --git a/ssl/dtls_method.c b/ssl/dtls_method.c
index 89b5491..6576686 100644
--- a/ssl/dtls_method.c
+++ b/ssl/dtls_method.c
@@ -62,6 +62,7 @@
#include <openssl/buf.h>
#include <openssl/err.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -112,8 +113,8 @@
}
ssl->d1->r_epoch++;
- memset(&ssl->d1->bitmap, 0, sizeof(ssl->d1->bitmap));
- memset(ssl->s3->read_sequence, 0, sizeof(ssl->s3->read_sequence));
+ OPENSSL_memset(&ssl->d1->bitmap, 0, sizeof(ssl->d1->bitmap));
+ OPENSSL_memset(ssl->s3->read_sequence, 0, sizeof(ssl->s3->read_sequence));
SSL_AEAD_CTX_free(ssl->s3->aead_read_ctx);
ssl->s3->aead_read_ctx = aead_ctx;
@@ -122,9 +123,9 @@
static int dtls1_set_write_state(SSL *ssl, SSL_AEAD_CTX *aead_ctx) {
ssl->d1->w_epoch++;
- memcpy(ssl->d1->last_write_sequence, ssl->s3->write_sequence,
- sizeof(ssl->s3->write_sequence));
- memset(ssl->s3->write_sequence, 0, sizeof(ssl->s3->write_sequence));
+ OPENSSL_memcpy(ssl->d1->last_write_sequence, ssl->s3->write_sequence,
+ sizeof(ssl->s3->write_sequence));
+ OPENSSL_memset(ssl->s3->write_sequence, 0, sizeof(ssl->s3->write_sequence));
SSL_AEAD_CTX_free(ssl->s3->aead_write_ctx);
ssl->s3->aead_write_ctx = aead_ctx;
diff --git a/ssl/dtls_record.c b/ssl/dtls_record.c
index ffe4053..e507f5c 100644
--- a/ssl/dtls_record.c
+++ b/ssl/dtls_record.c
@@ -283,7 +283,7 @@
out[3] = epoch >> 8;
out[4] = epoch & 0xff;
- memcpy(&out[5], &seq[2], 6);
+ OPENSSL_memcpy(&out[5], &seq[2], 6);
size_t ciphertext_len;
if (!SSL_AEAD_CTX_seal(aead, out + DTLS1_RT_HEADER_LENGTH, &ciphertext_len,
diff --git a/ssl/handshake_client.c b/ssl/handshake_client.c
index 8c21818..2791abc 100644
--- a/ssl/handshake_client.c
+++ b/ssl/handshake_client.c
@@ -167,6 +167,7 @@
#include <openssl/x509.h>
#include <openssl/x509v3.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -815,7 +816,7 @@
goto f_err;
}
- memcpy(ssl->d1->cookie, CBS_data(&cookie), CBS_len(&cookie));
+ OPENSSL_memcpy(ssl->d1->cookie, CBS_data(&cookie), CBS_len(&cookie));
ssl->d1->cookie_len = CBS_len(&cookie);
ssl->d1->send_cookie = 1;
@@ -913,7 +914,7 @@
}
/* Copy over the server random. */
- memcpy(ssl->s3->server_random, CBS_data(&server_random), SSL3_RANDOM_SIZE);
+ OPENSSL_memcpy(ssl->s3->server_random, CBS_data(&server_random), SSL3_RANDOM_SIZE);
/* TODO(davidben): Implement the TLS 1.1 and 1.2 downgrade sentinels once TLS
* 1.3 is finalized and we are not implementing a draft version. */
@@ -932,7 +933,7 @@
}
/* Note: session_id could be empty. */
ssl->s3->new_session->session_id_length = CBS_len(&session_id);
- memcpy(ssl->s3->new_session->session_id, CBS_data(&session_id),
+ OPENSSL_memcpy(ssl->s3->new_session->session_id, CBS_data(&session_id),
CBS_len(&session_id));
}
@@ -1515,7 +1516,7 @@
}
char identity[PSK_MAX_IDENTITY_LEN + 1];
- memset(identity, 0, sizeof(identity));
+ OPENSSL_memset(identity, 0, sizeof(identity));
psk_len =
ssl->psk_client_callback(ssl, hs->peer_psk_identity_hint, identity,
sizeof(identity), psk, sizeof(psk));
@@ -1616,7 +1617,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
goto err;
}
- memset(pms, 0, pms_len);
+ OPENSSL_memset(pms, 0, pms_len);
} else {
ssl3_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
diff --git a/ssl/handshake_server.c b/ssl/handshake_server.c
index d41685e..909e921 100644
--- a/ssl/handshake_server.c
+++ b/ssl/handshake_server.c
@@ -881,12 +881,12 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
return -1;
}
- memcpy(ssl->s3->client_random, client_hello.random,
- client_hello.random_len);
+ OPENSSL_memcpy(ssl->s3->client_random, client_hello.random,
+ client_hello.random_len);
/* Only null compression is supported. */
- if (memchr(client_hello.compression_methods, 0,
- client_hello.compression_methods_len) == NULL) {
+ if (OPENSSL_memchr(client_hello.compression_methods, 0,
+ client_hello.compression_methods_len) == NULL) {
al = SSL_AD_ILLEGAL_PARAMETER;
OPENSSL_PUT_ERROR(SSL, SSL_R_NO_COMPRESSION_SPECIFIED);
goto f_err;
@@ -1736,7 +1736,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
goto err;
}
- memset(premaster_secret, 0, premaster_secret_len);
+ OPENSSL_memset(premaster_secret, 0, premaster_secret_len);
} else {
al = SSL_AD_HANDSHAKE_FAILURE;
OPENSSL_PUT_ERROR(SSL, SSL_R_UNKNOWN_CIPHER_TYPE);
diff --git a/ssl/s3_both.c b/ssl/s3_both.c
index 3a96abc..a0594f4 100644
--- a/ssl/s3_both.c
+++ b/ssl/s3_both.c
@@ -127,6 +127,7 @@
#include <openssl/sha.h>
#include <openssl/x509.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -136,7 +137,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
return NULL;
}
- memset(hs, 0, sizeof(SSL_HANDSHAKE));
+ OPENSSL_memset(hs, 0, sizeof(SSL_HANDSHAKE));
hs->ssl = ssl;
hs->wait = ssl_hs_ok;
hs->state = SSL_ST_INIT;
@@ -295,10 +296,10 @@
}
if (ssl->server) {
- memcpy(ssl->s3->previous_server_finished, finished, finished_len);
+ OPENSSL_memcpy(ssl->s3->previous_server_finished, finished, finished_len);
ssl->s3->previous_server_finished_len = finished_len;
} else {
- memcpy(ssl->s3->previous_client_finished, finished, finished_len);
+ OPENSSL_memcpy(ssl->s3->previous_client_finished, finished, finished_len);
ssl->s3->previous_client_finished_len = finished_len;
}
}
@@ -353,10 +354,10 @@
}
if (ssl->server) {
- memcpy(ssl->s3->previous_client_finished, finished, finished_len);
+ OPENSSL_memcpy(ssl->s3->previous_client_finished, finished, finished_len);
ssl->s3->previous_client_finished_len = finished_len;
} else {
- memcpy(ssl->s3->previous_server_finished, finished, finished_len);
+ OPENSSL_memcpy(ssl->s3->previous_server_finished, finished, finished_len);
ssl->s3->previous_server_finished_len = finished_len;
}
}
@@ -521,9 +522,9 @@
rand_len = SSL3_RANDOM_SIZE;
}
uint8_t random[SSL3_RANDOM_SIZE];
- memset(random, 0, SSL3_RANDOM_SIZE);
- memcpy(random + (SSL3_RANDOM_SIZE - rand_len), CBS_data(&challenge),
- rand_len);
+ OPENSSL_memset(random, 0, SSL3_RANDOM_SIZE);
+ OPENSSL_memcpy(random + (SSL3_RANDOM_SIZE - rand_len), CBS_data(&challenge),
+ rand_len);
/* Write out an equivalent SSLv3 ClientHello. */
size_t max_v3_client_hello = SSL3_HM_HEADER_LENGTH + 2 /* version */ +
diff --git a/ssl/s3_enc.c b/ssl/s3_enc.c
index 7cdc294..bf82e08 100644
--- a/ssl/s3_enc.c
+++ b/ssl/s3_enc.c
@@ -144,8 +144,10 @@
#include <openssl/md5.h>
#include <openssl/nid.h>
+#include "../crypto/internal.h"
#include "internal.h"
+
static int ssl3_prf(const SSL *ssl, uint8_t *out, size_t out_len,
const uint8_t *secret, size_t secret_len, const char *label,
size_t label_len, const uint8_t *seed1, size_t seed1_len,
@@ -194,7 +196,7 @@
EVP_DigestUpdate(&md5, smd, SHA_DIGEST_LENGTH);
if (i + MD5_DIGEST_LENGTH > out_len) {
EVP_DigestFinal_ex(&md5, smd, NULL);
- memcpy(out, smd, out_len - i);
+ OPENSSL_memcpy(out, smd, out_len - i);
} else {
EVP_DigestFinal_ex(&md5, out, NULL);
}
@@ -269,7 +271,8 @@
if (!BUF_MEM_grow(ssl->s3->handshake_buffer, new_len)) {
return 0;
}
- memcpy(ssl->s3->handshake_buffer->data + new_len - in_len, in, in_len);
+ OPENSSL_memcpy(ssl->s3->handshake_buffer->data + new_len - in_len, in,
+ in_len);
}
if (EVP_MD_CTX_md(&ssl->s3->handshake_hash) != NULL) {
diff --git a/ssl/s3_lib.c b/ssl/s3_lib.c
index 3b14411..7039418 100644
--- a/ssl/s3_lib.c
+++ b/ssl/s3_lib.c
@@ -159,6 +159,7 @@
#include <openssl/mem.h>
#include <openssl/nid.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -169,7 +170,7 @@
if (s3 == NULL) {
return 0;
}
- memset(s3, 0, sizeof *s3);
+ OPENSSL_memset(s3, 0, sizeof *s3);
s3->hs = ssl_handshake_new(ssl);
if (s3->hs == NULL) {
diff --git a/ssl/s3_pkt.c b/ssl/s3_pkt.c
index e4116fb..9bd9f1f 100644
--- a/ssl/s3_pkt.c
+++ b/ssl/s3_pkt.c
@@ -118,6 +118,7 @@
#include <openssl/mem.h>
#include <openssl/rand.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -319,7 +320,7 @@
len = (int)rr->length;
}
- memcpy(out, rr->data, len);
+ OPENSSL_memcpy(out, rr->data, len);
if (!peek) {
rr->length -= len;
rr->data += len;
diff --git a/ssl/ssl_aead_ctx.c b/ssl/ssl_aead_ctx.c
index b05df0b..1b95150 100644
--- a/ssl/ssl_aead_ctx.c
+++ b/ssl/ssl_aead_ctx.c
@@ -22,6 +22,7 @@
#include <openssl/rand.h>
#include <openssl/type_check.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -52,9 +53,10 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
return 0;
}
- memcpy(merged_key, mac_key, mac_key_len);
- memcpy(merged_key + mac_key_len, enc_key, enc_key_len);
- memcpy(merged_key + mac_key_len + enc_key_len, fixed_iv, fixed_iv_len);
+ OPENSSL_memcpy(merged_key, mac_key, mac_key_len);
+ OPENSSL_memcpy(merged_key + mac_key_len, enc_key, enc_key_len);
+ OPENSSL_memcpy(merged_key + mac_key_len + enc_key_len, fixed_iv,
+ fixed_iv_len);
enc_key = merged_key;
enc_key_len += mac_key_len;
enc_key_len += fixed_iv_len;
@@ -65,7 +67,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
return NULL;
}
- memset(aead_ctx, 0, sizeof(SSL_AEAD_CTX));
+ OPENSSL_memset(aead_ctx, 0, sizeof(SSL_AEAD_CTX));
aead_ctx->cipher = cipher;
if (!EVP_AEAD_CTX_init_with_direction(
@@ -79,7 +81,7 @@
aead_ctx->variable_nonce_len = (uint8_t)EVP_AEAD_nonce_length(aead);
if (mac_key_len == 0) {
assert(fixed_iv_len <= sizeof(aead_ctx->fixed_nonce));
- memcpy(aead_ctx->fixed_nonce, fixed_iv, fixed_iv_len);
+ OPENSSL_memcpy(aead_ctx->fixed_nonce, fixed_iv, fixed_iv_len);
aead_ctx->fixed_nonce_len = fixed_iv_len;
if (cipher->algorithm_enc & SSL_CHACHA20POLY1305) {
@@ -158,7 +160,7 @@
return 0;
}
- memcpy(out, seqnum, 8);
+ OPENSSL_memcpy(out, seqnum, 8);
size_t len = 8;
out[len++] = type;
if (!aead->omit_version_in_ad) {
@@ -208,9 +210,9 @@
/* Prepend the fixed nonce, or left-pad with zeros if XORing. */
if (aead->xor_fixed_nonce) {
nonce_len = aead->fixed_nonce_len - aead->variable_nonce_len;
- memset(nonce, 0, nonce_len);
+ OPENSSL_memset(nonce, 0, nonce_len);
} else {
- memcpy(nonce, aead->fixed_nonce, aead->fixed_nonce_len);
+ OPENSSL_memcpy(nonce, aead->fixed_nonce, aead->fixed_nonce_len);
nonce_len += aead->fixed_nonce_len;
}
@@ -221,12 +223,12 @@
OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_PACKET_LENGTH);
return 0;
}
- memcpy(nonce + nonce_len, in, aead->variable_nonce_len);
+ OPENSSL_memcpy(nonce + nonce_len, in, aead->variable_nonce_len);
in += aead->variable_nonce_len;
in_len -= aead->variable_nonce_len;
} else {
assert(aead->variable_nonce_len == 8);
- memcpy(nonce + nonce_len, seqnum, aead->variable_nonce_len);
+ OPENSSL_memcpy(nonce + nonce_len, seqnum, aead->variable_nonce_len);
}
nonce_len += aead->variable_nonce_len;
@@ -262,7 +264,7 @@
OPENSSL_PUT_ERROR(SSL, SSL_R_BUFFER_TOO_SMALL);
return 0;
}
- memmove(out, in, in_len);
+ OPENSSL_memmove(out, in, in_len);
*out_len = in_len;
return 1;
}
@@ -278,9 +280,9 @@
/* Prepend the fixed nonce, or left-pad with zeros if XORing. */
if (aead->xor_fixed_nonce) {
nonce_len = aead->fixed_nonce_len - aead->variable_nonce_len;
- memset(nonce, 0, nonce_len);
+ OPENSSL_memset(nonce, 0, nonce_len);
} else {
- memcpy(nonce, aead->fixed_nonce, aead->fixed_nonce_len);
+ OPENSSL_memcpy(nonce, aead->fixed_nonce, aead->fixed_nonce_len);
nonce_len += aead->fixed_nonce_len;
}
@@ -294,7 +296,7 @@
/* When sending we use the sequence number as the variable part of the
* nonce. */
assert(aead->variable_nonce_len == 8);
- memcpy(nonce + nonce_len, seqnum, aead->variable_nonce_len);
+ OPENSSL_memcpy(nonce + nonce_len, seqnum, aead->variable_nonce_len);
}
nonce_len += aead->variable_nonce_len;
@@ -310,7 +312,8 @@
OPENSSL_PUT_ERROR(SSL, SSL_R_OUTPUT_ALIASES_INPUT);
return 0;
}
- memcpy(out, nonce + aead->fixed_nonce_len, aead->variable_nonce_len);
+ OPENSSL_memcpy(out, nonce + aead->fixed_nonce_len,
+ aead->variable_nonce_len);
extra_len = aead->variable_nonce_len;
out += aead->variable_nonce_len;
max_out -= aead->variable_nonce_len;
diff --git a/ssl/ssl_asn1.c b/ssl/ssl_asn1.c
index 902b580..d8a7d8f 100644
--- a/ssl/ssl_asn1.c
+++ b/ssl/ssl_asn1.c
@@ -91,6 +91,7 @@
#include <openssl/mem.h>
#include <openssl/x509.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -443,7 +444,7 @@
}
if (pp) {
- memcpy(*pp, out, len);
+ OPENSSL_memcpy(*pp, out, len);
*pp += len;
}
OPENSSL_free(out);
@@ -510,7 +511,7 @@
OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION);
return 0;
}
- memcpy(out, CBS_data(&value), CBS_len(&value));
+ OPENSSL_memcpy(out, CBS_data(&value), CBS_len(&value));
*out_len = (uint8_t)CBS_len(&value);
return 1;
}
@@ -593,9 +594,9 @@
OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION);
goto err;
}
- memcpy(ret->session_id, CBS_data(&session_id), CBS_len(&session_id));
+ OPENSSL_memcpy(ret->session_id, CBS_data(&session_id), CBS_len(&session_id));
ret->session_id_length = CBS_len(&session_id);
- memcpy(ret->master_key, CBS_data(&master_key), CBS_len(&master_key));
+ OPENSSL_memcpy(ret->master_key, CBS_data(&master_key), CBS_len(&master_key));
ret->master_key_length = CBS_len(&master_key);
CBS child;
@@ -647,7 +648,8 @@
OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_SSL_SESSION);
goto err;
}
- memcpy(ret->peer_sha256, CBS_data(&peer_sha256), sizeof(ret->peer_sha256));
+ OPENSSL_memcpy(ret->peer_sha256, CBS_data(&peer_sha256),
+ sizeof(ret->peer_sha256));
ret->peer_sha256_valid = 1;
} else {
ret->peer_sha256_valid = 0;
diff --git a/ssl/ssl_buffer.c b/ssl/ssl_buffer.c
index 7feb161..c27db8b 100644
--- a/ssl/ssl_buffer.c
+++ b/ssl/ssl_buffer.c
@@ -24,6 +24,7 @@
#include <openssl/mem.h>
#include <openssl/type_check.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -67,7 +68,7 @@
static void clear_buffer(SSL3_BUFFER *buf) {
OPENSSL_free(buf->buf);
- memset(buf, 0, sizeof(SSL3_BUFFER));
+ OPENSSL_memset(buf, 0, sizeof(SSL3_BUFFER));
}
OPENSSL_COMPILE_ASSERT(DTLS1_RT_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH <=
diff --git a/ssl/ssl_cert.c b/ssl/ssl_cert.c
index 277ee4d..3eaf499 100644
--- a/ssl/ssl_cert.c
+++ b/ssl/ssl_cert.c
@@ -147,7 +147,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
return NULL;
}
- memset(ret, 0, sizeof(CERT));
+ OPENSSL_memset(ret, 0, sizeof(CERT));
return ret;
}
@@ -158,7 +158,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
return NULL;
}
- memset(ret, 0, sizeof(CERT));
+ OPENSSL_memset(ret, 0, sizeof(CERT));
if (cert->x509_leaf != NULL) {
X509_up_ref(cert->x509_leaf);
@@ -707,7 +707,8 @@
static const uint8_t kKeyUsageOID[3] = {0x55, 0x1d, 0x0f};
if (CBS_len(&oid) != sizeof(kKeyUsageOID) ||
- memcmp(CBS_data(&oid), kKeyUsageOID, sizeof(kKeyUsageOID)) != 0) {
+ OPENSSL_memcmp(CBS_data(&oid), kKeyUsageOID, sizeof(kKeyUsageOID)) !=
+ 0) {
continue;
}
diff --git a/ssl/ssl_cipher.c b/ssl/ssl_cipher.c
index 5223721..20b075e 100644
--- a/ssl/ssl_cipher.c
+++ b/ssl/ssl_cipher.c
@@ -1073,7 +1073,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
return 0;
}
- memset(number_uses, 0, (max_strength_bits + 1) * sizeof(int));
+ OPENSSL_memset(number_uses, 0, (max_strength_bits + 1) * sizeof(int));
/* Now find the strength_bits values actually used. */
curr = *head_p;
@@ -1437,7 +1437,7 @@
if (!pref_list->in_group_flags) {
goto err;
}
- memcpy(pref_list->in_group_flags, in_group_flags, num_in_group_flags);
+ OPENSSL_memcpy(pref_list->in_group_flags, in_group_flags, num_in_group_flags);
OPENSSL_free(in_group_flags);
in_group_flags = NULL;
if (*out_cipher_list != NULL) {
diff --git a/ssl/ssl_lib.c b/ssl/ssl_lib.c
index eee2fb2..f428104 100644
--- a/ssl/ssl_lib.c
+++ b/ssl/ssl_lib.c
@@ -196,8 +196,8 @@
uint8_t tmp_storage[sizeof(uint32_t)];
if (sess->session_id_length < sizeof(tmp_storage)) {
- memset(tmp_storage, 0, sizeof(tmp_storage));
- memcpy(tmp_storage, sess->session_id, sess->session_id_length);
+ OPENSSL_memset(tmp_storage, 0, sizeof(tmp_storage));
+ OPENSSL_memcpy(tmp_storage, sess->session_id, sess->session_id_length);
session_id = tmp_storage;
}
@@ -224,7 +224,7 @@
return 1;
}
- return memcmp(a->session_id, b->session_id, a->session_id_length);
+ return OPENSSL_memcmp(a->session_id, b->session_id, a->session_id_length);
}
SSL_CTX *SSL_CTX_new(const SSL_METHOD *method) {
@@ -245,7 +245,7 @@
goto err;
}
- memset(ret, 0, sizeof(SSL_CTX));
+ OPENSSL_memset(ret, 0, sizeof(SSL_CTX));
ret->method = method->method;
@@ -383,7 +383,7 @@
if (ssl == NULL) {
goto err;
}
- memset(ssl, 0, sizeof(SSL));
+ OPENSSL_memset(ssl, 0, sizeof(SSL));
ssl->min_version = ctx->min_version;
ssl->max_version = ctx->max_version;
@@ -406,7 +406,7 @@
ssl->verify_mode = ctx->verify_mode;
ssl->sid_ctx_length = ctx->sid_ctx_length;
assert(ssl->sid_ctx_length <= sizeof ssl->sid_ctx);
- memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
+ OPENSSL_memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
ssl->verify_callback = ctx->default_verify_callback;
ssl->retain_only_sha256_of_client_certs =
ctx->retain_only_sha256_of_client_certs;
@@ -1157,12 +1157,12 @@
*out_len = max_out;
}
- memcpy(out, finished, *out_len);
+ OPENSSL_memcpy(out, finished, *out_len);
return 1;
err:
*out_len = 0;
- memset(out, 0, max_out);
+ OPENSSL_memset(out, 0, max_out);
return 0;
}
@@ -1175,7 +1175,7 @@
assert(sizeof(ctx->sid_ctx) < 256);
ctx->sid_ctx_length = (uint8_t)sid_ctx_len;
- memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len);
+ OPENSSL_memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len);
return 1;
}
@@ -1189,7 +1189,7 @@
assert(sizeof(ssl->sid_ctx) < 256);
ssl->sid_ctx_length = (uint8_t)sid_ctx_len;
- memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
+ OPENSSL_memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
return 1;
}
@@ -1309,7 +1309,7 @@
if (out_len > in_len) {
out_len = in_len;
}
- memcpy(out, in, out_len);
+ OPENSSL_memcpy(out, in, out_len);
return in_len;
}
@@ -1545,9 +1545,9 @@
return 0;
}
uint8_t *out_bytes = out;
- memcpy(out_bytes, ctx->tlsext_tick_key_name, 16);
- memcpy(out_bytes + 16, ctx->tlsext_tick_hmac_key, 16);
- memcpy(out_bytes + 32, ctx->tlsext_tick_aes_key, 16);
+ OPENSSL_memcpy(out_bytes, ctx->tlsext_tick_key_name, 16);
+ OPENSSL_memcpy(out_bytes + 16, ctx->tlsext_tick_hmac_key, 16);
+ OPENSSL_memcpy(out_bytes + 32, ctx->tlsext_tick_aes_key, 16);
return 1;
}
@@ -1560,9 +1560,9 @@
return 0;
}
const uint8_t *in_bytes = in;
- memcpy(ctx->tlsext_tick_key_name, in_bytes, 16);
- memcpy(ctx->tlsext_tick_hmac_key, in_bytes + 16, 16);
- memcpy(ctx->tlsext_tick_aes_key, in_bytes + 32, 16);
+ OPENSSL_memcpy(ctx->tlsext_tick_key_name, in_bytes, 16);
+ OPENSSL_memcpy(ctx->tlsext_tick_hmac_key, in_bytes + 16, 16);
+ OPENSSL_memcpy(ctx->tlsext_tick_aes_key, in_bytes + 32, 16);
return 1;
}
@@ -1844,7 +1844,7 @@
for (i = 0; i < server_len;) {
for (j = 0; j < client_len;) {
if (server[i] == client[j] &&
- memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) {
+ OPENSSL_memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) {
/* We found a match */
result = &server[i];
status = OPENSSL_NPN_NEGOTIATED;
@@ -1996,7 +1996,8 @@
if (!ssl->s3->tlsext_channel_id_valid) {
return 0;
}
- memcpy(out, ssl->s3->tlsext_channel_id, (max_out < 64) ? max_out : 64);
+ OPENSSL_memcpy(out, ssl->s3->tlsext_channel_id,
+ (max_out < 64) ? max_out : 64);
return 64;
}
@@ -2271,7 +2272,7 @@
ssl->sid_ctx_length = ctx->sid_ctx_length;
assert(ssl->sid_ctx_length <= sizeof(ssl->sid_ctx));
- memcpy(ssl->sid_ctx, ctx->sid_ctx, sizeof(ssl->sid_ctx));
+ OPENSSL_memcpy(ssl->sid_ctx, ctx->sid_ctx, sizeof(ssl->sid_ctx));
return ssl->ctx;
}
@@ -2835,7 +2836,7 @@
if (max_out > sizeof(ssl->s3->client_random)) {
max_out = sizeof(ssl->s3->client_random);
}
- memcpy(out, ssl->s3->client_random, max_out);
+ OPENSSL_memcpy(out, ssl->s3->client_random, max_out);
return max_out;
}
@@ -2846,7 +2847,7 @@
if (max_out > sizeof(ssl->s3->server_random)) {
max_out = sizeof(ssl->s3->server_random);
}
- memcpy(out, ssl->s3->server_random, max_out);
+ OPENSSL_memcpy(out, ssl->s3->server_random, max_out);
return max_out;
}
diff --git a/ssl/ssl_session.c b/ssl/ssl_session.c
index d6d7dab..62ee28e 100644
--- a/ssl/ssl_session.c
+++ b/ssl/ssl_session.c
@@ -166,7 +166,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
return 0;
}
- memset(session, 0, sizeof(SSL_SESSION));
+ OPENSSL_memset(session, 0, sizeof(SSL_SESSION));
session->verify_result = X509_V_ERR_INVALID_CALL;
session->references = 1;
@@ -185,11 +185,11 @@
new_session->is_server = session->is_server;
new_session->ssl_version = session->ssl_version;
new_session->sid_ctx_length = session->sid_ctx_length;
- memcpy(new_session->sid_ctx, session->sid_ctx, session->sid_ctx_length);
+ OPENSSL_memcpy(new_session->sid_ctx, session->sid_ctx, session->sid_ctx_length);
/* Copy the key material. */
new_session->master_key_length = session->master_key_length;
- memcpy(new_session->master_key, session->master_key,
+ OPENSSL_memcpy(new_session->master_key, session->master_key,
session->master_key_length);
new_session->cipher = session->cipher;
@@ -245,7 +245,8 @@
}
}
- memcpy(new_session->peer_sha256, session->peer_sha256, SHA256_DIGEST_LENGTH);
+ OPENSSL_memcpy(new_session->peer_sha256, session->peer_sha256,
+ SHA256_DIGEST_LENGTH);
new_session->peer_sha256_valid = session->peer_sha256_valid;
if (session->tlsext_hostname != NULL) {
@@ -263,14 +264,14 @@
/* Copy non-authentication connection properties. */
if (dup_flags & SSL_SESSION_INCLUDE_NONAUTH) {
new_session->session_id_length = session->session_id_length;
- memcpy(new_session->session_id, session->session_id,
- session->session_id_length);
+ OPENSSL_memcpy(new_session->session_id, session->session_id,
+ session->session_id_length);
new_session->group_id = session->group_id;
- memcpy(new_session->original_handshake_hash,
- session->original_handshake_hash,
- session->original_handshake_hash_len);
+ OPENSSL_memcpy(new_session->original_handshake_hash,
+ session->original_handshake_hash,
+ session->original_handshake_hash_len);
new_session->original_handshake_hash_len =
session->original_handshake_hash_len;
new_session->tlsext_tick_lifetime_hint = session->tlsext_tick_lifetime_hint;
@@ -387,7 +388,7 @@
if (max_out > (size_t)session->master_key_length) {
max_out = (size_t)session->master_key_length;
}
- memcpy(out, session->master_key, max_out);
+ OPENSSL_memcpy(out, session->master_key, max_out);
return max_out;
}
@@ -418,7 +419,7 @@
assert(sizeof(session->sid_ctx) < 256);
session->sid_ctx_length = (uint8_t)sid_ctx_len;
- memcpy(session->sid_ctx, sid_ctx, sid_ctx_len);
+ OPENSSL_memcpy(session->sid_ctx, sid_ctx, sid_ctx_len);
return 1;
}
@@ -517,7 +518,7 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
goto err;
}
- memcpy(session->sid_ctx, ssl->sid_ctx, ssl->sid_ctx_length);
+ OPENSSL_memcpy(session->sid_ctx, ssl->sid_ctx, ssl->sid_ctx_length);
session->sid_ctx_length = ssl->sid_ctx_length;
/* The session is marked not resumable until it is completely filled in. */
@@ -627,7 +628,7 @@
NULL)) {
goto err;
}
- memcpy(key_name, tctx->tlsext_tick_key_name, 16);
+ OPENSSL_memcpy(key_name, tctx->tlsext_tick_key_name, 16);
}
uint8_t *ptr;
@@ -639,7 +640,7 @@
size_t total = 0;
#if defined(BORINGSSL_UNSAFE_FUZZER_MODE)
- memcpy(ptr, session_buf, session_len);
+ OPENSSL_memcpy(ptr, session_buf, session_len);
total = session_len;
#else
int len;
@@ -679,7 +680,8 @@
}
return session->sid_ctx_length == ssl->sid_ctx_length &&
- memcmp(session->sid_ctx, ssl->sid_ctx, ssl->sid_ctx_length) == 0;
+ OPENSSL_memcmp(session->sid_ctx, ssl->sid_ctx, ssl->sid_ctx_length) ==
+ 0;
}
int ssl_session_is_time_valid(const SSL *ssl, const SSL_SESSION *session) {
@@ -737,7 +739,7 @@
SSL_SESSION data;
data.ssl_version = ssl->version;
data.session_id_length = session_id_len;
- memcpy(data.session_id, session_id, session_id_len);
+ OPENSSL_memcpy(data.session_id, session_id, session_id_len);
CRYPTO_MUTEX_lock_read(&ssl->initial_ctx->lock);
session = lh_SSL_SESSION_retrieve(ssl->initial_ctx->sessions, &data);
diff --git a/ssl/ssl_test.cc b/ssl/ssl_test.cc
index 8ede63c..796c051 100644
--- a/ssl/ssl_test.cc
+++ b/ssl/ssl_test.cc
@@ -673,7 +673,7 @@
}
encoded.reset(encoded_raw);
if (encoded_len != input.size() ||
- memcmp(input.data(), encoded.get(), input.size()) != 0) {
+ OPENSSL_memcmp(input.data(), encoded.get(), input.size()) != 0) {
fprintf(stderr, "SSL_SESSION_to_bytes did not round-trip\n");
hexdump(stderr, "Before: ", input.data(), input.size());
hexdump(stderr, "After: ", encoded_raw, encoded_len);
@@ -711,7 +711,7 @@
fprintf(stderr, "i2d_SSL_SESSION did not advance ptr correctly\n");
return false;
}
- if (memcmp(input.data(), encoded.get(), input.size()) != 0) {
+ if (OPENSSL_memcmp(input.data(), encoded.get(), input.size()) != 0) {
fprintf(stderr, "i2d_SSL_SESSION did not round-trip\n");
return false;
}
@@ -838,7 +838,7 @@
if (session->tlsext_tick == nullptr) {
return nullptr;
}
- memset(session->tlsext_tick, 'a', ticket_len);
+ OPENSSL_memset(session->tlsext_tick, 'a', ticket_len);
session->tlsext_ticklen = ticket_len;
// Fix up the timeout.
@@ -1030,8 +1030,8 @@
}
ret->session_id_length = SSL3_SSL_SESSION_ID_LENGTH;
- memset(ret->session_id, 0, ret->session_id_length);
- memcpy(ret->session_id, &number, sizeof(number));
+ OPENSSL_memset(ret->session_id, 0, ret->session_id_length);
+ OPENSSL_memcpy(ret->session_id, &number, sizeof(number));
return ret;
}
@@ -1442,7 +1442,7 @@
}
bssl::UniquePtr<uint8_t> free_s1(s1_bytes);
- return s0_len == s1_len && memcmp(s0_bytes, s1_bytes, s0_len) == 0;
+ return s0_len == s1_len && OPENSSL_memcmp(s0_bytes, s1_bytes, s0_len) == 0;
}
static bool ExpectFDs(const SSL *ssl, int rfd, int wfd) {
@@ -1711,7 +1711,8 @@
return false;
}
- if (memcmp(cert_sha256, session->peer_sha256, SHA256_DIGEST_LENGTH) != 0) {
+ if (OPENSSL_memcmp(cert_sha256, session->peer_sha256, SHA256_DIGEST_LENGTH) !=
+ 0) {
fprintf(stderr, "peer_sha256 did not match.\n");
return false;
}
@@ -1747,10 +1748,10 @@
fprintf(stderr, "ClientHello for version %04x too short.\n", version);
return false;
}
- memset(client_hello.data() + kRandomOffset, 0, SSL3_RANDOM_SIZE);
+ OPENSSL_memset(client_hello.data() + kRandomOffset, 0, SSL3_RANDOM_SIZE);
if (client_hello.size() != expected_len ||
- memcmp(client_hello.data(), expected, expected_len) != 0) {
+ OPENSSL_memcmp(client_hello.data(), expected, expected_len) != 0) {
fprintf(stderr, "ClientHello for version %04x did not match:\n", version);
fprintf(stderr, "Got:\n\t");
for (size_t i = 0; i < client_hello.size(); i++) {
@@ -2097,9 +2098,9 @@
static const uint8_t kZeros[16] = {0};
if (encrypt) {
- memcpy(key_name, kZeros, sizeof(kZeros));
+ OPENSSL_memcpy(key_name, kZeros, sizeof(kZeros));
RAND_bytes(iv, 16);
- } else if (memcmp(key_name, kZeros, 16) != 0) {
+ } else if (OPENSSL_memcmp(key_name, kZeros, 16) != 0) {
return 0;
}
@@ -2124,7 +2125,7 @@
#if defined(BORINGSSL_UNSAFE_FUZZER_MODE)
// Fuzzer-mode tickets are unencrypted.
- memcpy(plaintext.get(), ciphertext, len);
+ OPENSSL_memcpy(plaintext.get(), ciphertext, len);
#else
static const uint8_t kZeros[16] = {0};
const uint8_t *iv = session->tlsext_tick + 16;
diff --git a/ssl/t1_enc.c b/ssl/t1_enc.c
index 70907e1..5e5c348 100644
--- a/ssl/t1_enc.c
+++ b/ssl/t1_enc.c
@@ -146,6 +146,7 @@
#include <openssl/nid.h>
#include <openssl/rand.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -231,7 +232,7 @@
return 1;
}
- memset(out, 0, out_len);
+ OPENSSL_memset(out, 0, out_len);
uint32_t algorithm_prf = ssl_get_algorithm_prf(ssl);
if (algorithm_prf == SSL_HANDSHAKE_MAC_DEFAULT) {
@@ -528,12 +529,13 @@
return 0;
}
- memcpy(seed, ssl->s3->client_random, SSL3_RANDOM_SIZE);
- memcpy(seed + SSL3_RANDOM_SIZE, ssl->s3->server_random, SSL3_RANDOM_SIZE);
+ OPENSSL_memcpy(seed, ssl->s3->client_random, SSL3_RANDOM_SIZE);
+ OPENSSL_memcpy(seed + SSL3_RANDOM_SIZE, ssl->s3->server_random,
+ SSL3_RANDOM_SIZE);
if (use_context) {
seed[2 * SSL3_RANDOM_SIZE] = (uint8_t)(context_len >> 8);
seed[2 * SSL3_RANDOM_SIZE + 1] = (uint8_t)context_len;
- memcpy(seed + 2 * SSL3_RANDOM_SIZE + 2, context, context_len);
+ OPENSSL_memcpy(seed + 2 * SSL3_RANDOM_SIZE + 2, context, context_len);
}
int ret =
diff --git a/ssl/t1_lib.c b/ssl/t1_lib.c
index 8d91cfc..c27e84d 100644
--- a/ssl/t1_lib.c
+++ b/ssl/t1_lib.c
@@ -205,7 +205,7 @@
int ssl_client_hello_init(SSL *ssl, SSL_CLIENT_HELLO *out, const uint8_t *in,
size_t in_len) {
- memset(out, 0, sizeof(*out));
+ OPENSSL_memset(out, 0, sizeof(*out));
out->ssl = ssl;
out->client_hello = in;
out->client_hello_len = in_len;
@@ -1506,8 +1506,9 @@
}
if (CBS_len(&client_protocol_name) == CBS_len(&protocol_name) &&
- memcmp(CBS_data(&client_protocol_name), CBS_data(&protocol_name),
- CBS_len(&protocol_name)) == 0) {
+ OPENSSL_memcmp(CBS_data(&client_protocol_name),
+ CBS_data(&protocol_name),
+ CBS_len(&protocol_name)) == 0) {
protocol_ok = 1;
break;
}
@@ -1881,8 +1882,9 @@
/* Per RFC 4492, section 5.1.2, implementations MUST support the uncompressed
* point format. */
- if (memchr(CBS_data(&ec_point_format_list), TLSEXT_ECPOINTFORMAT_uncompressed,
- CBS_len(&ec_point_format_list)) == NULL) {
+ if (OPENSSL_memchr(CBS_data(&ec_point_format_list),
+ TLSEXT_ECPOINTFORMAT_uncompressed,
+ CBS_len(&ec_point_format_list)) == NULL) {
*out_alert = SSL_AD_ILLEGAL_PARAMETER;
return 0;
}
@@ -2141,8 +2143,8 @@
}
/* We only support tickets with PSK_DHE_KE. */
- hs->accept_psk_mode =
- memchr(CBS_data(&ke_modes), SSL_PSK_DHE_KE, CBS_len(&ke_modes)) != NULL;
+ hs->accept_psk_mode = OPENSSL_memchr(CBS_data(&ke_modes), SSL_PSK_DHE_KE,
+ CBS_len(&ke_modes)) != NULL;
return 1;
}
@@ -2343,7 +2345,7 @@
uint8_t *secret = NULL;
size_t secret_len;
SSL_ECDH_CTX group;
- memset(&group, 0, sizeof(SSL_ECDH_CTX));
+ OPENSSL_memset(&group, 0, sizeof(SSL_ECDH_CTX));
CBB public_key;
if (!CBB_init(&public_key, 32) ||
!SSL_ECDH_CTX_init(&group, group_id) ||
@@ -2820,7 +2822,7 @@
goto err;
}
- memset(padding_bytes, 0, padding_len);
+ OPENSSL_memset(padding_bytes, 0, padding_len);
}
}
@@ -3183,8 +3185,8 @@
}
} else {
/* Check the key name matches. */
- if (memcmp(ticket, ssl_ctx->tlsext_tick_key_name,
- SSL_TICKET_KEY_NAME_LEN) != 0) {
+ if (OPENSSL_memcmp(ticket, ssl_ctx->tlsext_tick_key_name,
+ SSL_TICKET_KEY_NAME_LEN) != 0) {
goto done;
}
if (!HMAC_Init_ex(&hmac_ctx, ssl_ctx->tlsext_tick_hmac_key,
@@ -3227,7 +3229,7 @@
}
size_t plaintext_len;
#if defined(BORINGSSL_UNSAFE_FUZZER_MODE)
- memcpy(plaintext, ciphertext, ciphertext_len);
+ OPENSSL_memcpy(plaintext, ciphertext, ciphertext_len);
plaintext_len = ciphertext_len;
#else
if (ciphertext_len >= INT_MAX) {
@@ -3252,7 +3254,7 @@
/* Copy the client's session ID into the new session, to denote the ticket has
* been accepted. */
- memcpy(session->session_id, session_id, session_id_len);
+ OPENSSL_memcpy(session->session_id, session_id, session_id_len);
session->session_id_length = session_id_len;
*out_session = session;
@@ -3439,7 +3441,7 @@
goto err;
}
- memcpy(ssl->s3->tlsext_channel_id, p, 64);
+ OPENSSL_memcpy(ssl->s3->tlsext_channel_id, p, 64);
ret = 1;
err:
diff --git a/ssl/test/async_bio.cc b/ssl/test/async_bio.cc
index 605b33a..fd35176 100644
--- a/ssl/test/async_bio.cc
+++ b/ssl/test/async_bio.cc
@@ -20,6 +20,8 @@
#include <openssl/bio.h>
#include <openssl/mem.h>
+#include "../../crypto/internal.h"
+
namespace {
@@ -110,7 +112,7 @@
if (a == NULL) {
return 0;
}
- memset(a, 0, sizeof(*a));
+ OPENSSL_memset(a, 0, sizeof(*a));
a->enforce_write_quota = true;
bio->init = 1;
bio->ptr = (char *)a;
diff --git a/ssl/test/bssl_shim.cc b/ssl/test/bssl_shim.cc
index f2d6d9f..4425ab0 100644
--- a/ssl/test/bssl_shim.cc
+++ b/ssl/test/bssl_shim.cc
@@ -330,8 +330,8 @@
fprintf(stderr, "Output buffer too small.\n");
return ssl_private_key_failure;
}
- memcpy(out, test_state->private_key_result.data(),
- test_state->private_key_result.size());
+ OPENSSL_memcpy(out, test_state->private_key_result.data(),
+ test_state->private_key_result.size());
*out_len = test_state->private_key_result.size();
test_state->private_key_result.clear();
@@ -498,9 +498,9 @@
size_t certificate_types_len =
SSL_get0_certificate_types(ssl, &certificate_types);
if (certificate_types_len != config->expected_certificate_types.size() ||
- memcmp(certificate_types,
- config->expected_certificate_types.data(),
- certificate_types_len) != 0) {
+ OPENSSL_memcmp(certificate_types,
+ config->expected_certificate_types.data(),
+ certificate_types_len) != 0) {
fprintf(stderr, "certificate types mismatch\n");
return false;
}
@@ -626,8 +626,8 @@
if (!config->expected_advertised_alpn.empty() &&
(config->expected_advertised_alpn.size() != inlen ||
- memcmp(config->expected_advertised_alpn.data(),
- in, inlen) != 0)) {
+ OPENSSL_memcmp(config->expected_advertised_alpn.data(), in, inlen) !=
+ 0)) {
fprintf(stderr, "bad ALPN select callback inputs\n");
exit(1);
}
@@ -663,7 +663,7 @@
BUF_strlcpy(out_identity, config->psk_identity.c_str(),
max_identity_len);
- memcpy(out_psk, config->psk.data(), config->psk.size());
+ OPENSSL_memcpy(out_psk, config->psk.data(), config->psk.size());
return config->psk.size();
}
@@ -681,7 +681,7 @@
return 0;
}
- memcpy(out_psk, config->psk.data(), config->psk.size());
+ OPENSSL_memcpy(out_psk, config->psk.data(), config->psk.size());
return config->psk.size();
}
@@ -758,9 +758,9 @@
static const uint8_t kZeros[16] = {0};
if (encrypt) {
- memcpy(key_name, kZeros, sizeof(kZeros));
+ OPENSSL_memcpy(key_name, kZeros, sizeof(kZeros));
RAND_bytes(iv, 16);
- } else if (memcmp(key_name, kZeros, 16) != 0) {
+ } else if (OPENSSL_memcmp(key_name, kZeros, 16) != 0) {
return 0;
}
@@ -824,7 +824,7 @@
}
if (contents_len != sizeof(kCustomExtensionContents) - 1 ||
- memcmp(contents, kCustomExtensionContents, contents_len) != 0) {
+ OPENSSL_memcmp(contents, kCustomExtensionContents, contents_len) != 0) {
*out_alert_value = SSL_AD_DECODE_ERROR;
return 0;
}
@@ -862,7 +862,7 @@
return -1;
}
sockaddr_in sin;
- memset(&sin, 0, sizeof(sin));
+ OPENSSL_memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
if (!inet_pton(AF_INET, "127.0.0.1", &sin.sin_addr)) {
@@ -1143,7 +1143,7 @@
// SSL_peek should synchronously return the same data.
int ret2 = SSL_peek(ssl, buf.get(), ret);
if (ret2 != ret ||
- memcmp(buf.get(), out, ret) != 0) {
+ OPENSSL_memcmp(buf.get(), out, ret) != 0) {
fprintf(stderr, "First and second SSL_peek did not match.\n");
return -1;
}
@@ -1151,7 +1151,7 @@
// SSL_read should synchronously return the same data and consume it.
ret2 = SSL_read(ssl, buf.get(), ret);
if (ret2 != ret ||
- memcmp(buf.get(), out, ret) != 0) {
+ OPENSSL_memcmp(buf.get(), out, ret) != 0) {
fprintf(stderr, "SSL_peek and SSL_read did not match.\n");
return -1;
}
@@ -1265,8 +1265,8 @@
unsigned next_proto_len;
SSL_get0_next_proto_negotiated(ssl, &next_proto, &next_proto_len);
if (next_proto_len != config->expected_next_proto.size() ||
- memcmp(next_proto, config->expected_next_proto.data(),
- next_proto_len) != 0) {
+ OPENSSL_memcmp(next_proto, config->expected_next_proto.data(),
+ next_proto_len) != 0) {
fprintf(stderr, "negotiated next proto mismatch\n");
return false;
}
@@ -1277,8 +1277,8 @@
unsigned alpn_proto_len;
SSL_get0_alpn_selected(ssl, &alpn_proto, &alpn_proto_len);
if (alpn_proto_len != config->expected_alpn.size() ||
- memcmp(alpn_proto, config->expected_alpn.data(),
- alpn_proto_len) != 0) {
+ OPENSSL_memcmp(alpn_proto, config->expected_alpn.data(),
+ alpn_proto_len) != 0) {
fprintf(stderr, "negotiated alpn proto mismatch\n");
return false;
}
@@ -1291,8 +1291,8 @@
return false;
}
if (config->expected_channel_id.size() != 64 ||
- memcmp(config->expected_channel_id.data(),
- channel_id, 64) != 0) {
+ OPENSSL_memcmp(config->expected_channel_id.data(), channel_id, 64) !=
+ 0) {
fprintf(stderr, "channel id mismatch\n");
return false;
}
@@ -1310,7 +1310,7 @@
size_t len;
SSL_get0_ocsp_response(ssl, &data, &len);
if (config->expected_ocsp_response.size() != len ||
- memcmp(config->expected_ocsp_response.data(), data, len) != 0) {
+ OPENSSL_memcmp(config->expected_ocsp_response.data(), data, len) != 0) {
fprintf(stderr, "OCSP response mismatch\n");
return false;
}
@@ -1321,8 +1321,8 @@
size_t len;
SSL_get0_signed_cert_timestamp_list(ssl, &data, &len);
if (config->expected_signed_cert_timestamps.size() != len ||
- memcmp(config->expected_signed_cert_timestamps.data(),
- data, len) != 0) {
+ OPENSSL_memcmp(config->expected_signed_cert_timestamps.data(), data,
+ len) != 0) {
fprintf(stderr, "SCT list mismatch\n");
return false;
}
@@ -1743,7 +1743,7 @@
// trip up the CBC record splitting code.
static const size_t kBufLen = 32769;
std::unique_ptr<uint8_t[]> buf(new uint8_t[kBufLen]);
- memset(buf.get(), 0x42, kBufLen);
+ OPENSSL_memset(buf.get(), 0x42, kBufLen);
static const size_t kRecordSizes[] = {
0, 1, 255, 256, 257, 16383, 16384, 16385, 32767, 32768, 32769};
for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kRecordSizes); i++) {
diff --git a/ssl/test/packeted_bio.cc b/ssl/test/packeted_bio.cc
index 8331b4b..835df0e 100644
--- a/ssl/test/packeted_bio.cc
+++ b/ssl/test/packeted_bio.cc
@@ -21,6 +21,8 @@
#include <openssl/mem.h>
+#include "../../crypto/internal.h"
+
namespace {
@@ -33,8 +35,8 @@
struct PacketedBio {
PacketedBio(timeval *clock_arg, bool advance_clock_arg)
: clock(clock_arg), advance_clock(advance_clock_arg) {
- memset(&timeout, 0, sizeof(timeout));
- memset(&read_deadline, 0, sizeof(read_deadline));
+ OPENSSL_memset(&timeout, 0, sizeof(timeout));
+ OPENSSL_memset(&read_deadline, 0, sizeof(read_deadline));
}
bool HasTimeout() const {
@@ -209,7 +211,7 @@
if (outl > (int)len) {
outl = len;
}
- memcpy(out, buf, outl);
+ OPENSSL_memcpy(out, buf, outl);
OPENSSL_free(buf);
return outl;
}
@@ -217,7 +219,7 @@
static long PacketedCtrl(BIO *bio, int cmd, long num, void *ptr) {
if (cmd == BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT) {
- memcpy(&GetData(bio)->read_deadline, ptr, sizeof(timeval));
+ OPENSSL_memcpy(&GetData(bio)->read_deadline, ptr, sizeof(timeval));
return 1;
}
@@ -290,6 +292,6 @@
data->clock->tv_sec += data->clock->tv_usec / 1000000;
data->clock->tv_usec %= 1000000;
data->clock->tv_sec += data->timeout.tv_sec;
- memset(&data->timeout, 0, sizeof(data->timeout));
+ OPENSSL_memset(&data->timeout, 0, sizeof(data->timeout));
return true;
}
diff --git a/ssl/tls13_client.c b/ssl/tls13_client.c
index ea241c1..d19bc14 100644
--- a/ssl/tls13_client.c
+++ b/ssl/tls13_client.c
@@ -182,7 +182,8 @@
}
assert(ssl->s3->have_version);
- memcpy(ssl->s3->server_random, CBS_data(&server_random), SSL3_RANDOM_SIZE);
+ OPENSSL_memcpy(ssl->s3->server_random, CBS_data(&server_random),
+ SSL3_RANDOM_SIZE);
const SSL_CIPHER *cipher = SSL_get_cipher_by_value(cipher_suite);
if (cipher == NULL) {
diff --git a/ssl/tls13_enc.c b/ssl/tls13_enc.c
index b431b75..ea9dce8 100644
--- a/ssl/tls13_enc.c
+++ b/ssl/tls13_enc.c
@@ -24,6 +24,7 @@
#include <openssl/hmac.h>
#include <openssl/mem.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -34,7 +35,7 @@
hs->hash_len = EVP_MD_size(digest);
/* Initialize the secret to the zero key. */
- memset(hs->secret, 0, hs->hash_len);
+ OPENSSL_memset(hs->secret, 0, hs->hash_len);
/* Initialize the rolling hashes and release the handshake buffer. */
if (!ssl3_init_handshake_hash(ssl)) {
@@ -166,10 +167,12 @@
/* Save the traffic secret. */
if (direction == evp_aead_open) {
- memmove(ssl->s3->read_traffic_secret, traffic_secret, traffic_secret_len);
+ OPENSSL_memmove(ssl->s3->read_traffic_secret, traffic_secret,
+ traffic_secret_len);
ssl->s3->read_traffic_secret_len = traffic_secret_len;
} else {
- memmove(ssl->s3->write_traffic_secret, traffic_secret, traffic_secret_len);
+ OPENSSL_memmove(ssl->s3->write_traffic_secret, traffic_secret,
+ traffic_secret_len);
ssl->s3->write_traffic_secret_len = traffic_secret_len;
}
@@ -384,7 +387,7 @@
return 0;
}
- memcpy(msg + len - hash_len, verify_data, hash_len);
+ OPENSSL_memcpy(msg + len - hash_len, verify_data, hash_len);
return 1;
}
diff --git a/ssl/tls13_server.c b/ssl/tls13_server.c
index 7181f46..e3606f1 100644
--- a/ssl/tls13_server.c
+++ b/ssl/tls13_server.c
@@ -25,6 +25,7 @@
#include <openssl/rand.h>
#include <openssl/stack.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -109,7 +110,8 @@
OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
return ssl_hs_error;
}
- memcpy(ssl->s3->client_random, client_hello.random, client_hello.random_len);
+ OPENSSL_memcpy(ssl->s3->client_random, client_hello.random,
+ client_hello.random_len);
/* TLS 1.3 requires the peer only advertise the null compression. */
if (client_hello.compression_methods_len != 1 ||
diff --git a/ssl/tls_method.c b/ssl/tls_method.c
index 9effb36..4efed3f 100644
--- a/ssl/tls_method.c
+++ b/ssl/tls_method.c
@@ -61,6 +61,7 @@
#include <openssl/buf.h>
+#include "../crypto/internal.h"
#include "internal.h"
@@ -112,7 +113,7 @@
return 0;
}
- memset(ssl->s3->read_sequence, 0, sizeof(ssl->s3->read_sequence));
+ OPENSSL_memset(ssl->s3->read_sequence, 0, sizeof(ssl->s3->read_sequence));
SSL_AEAD_CTX_free(ssl->s3->aead_read_ctx);
ssl->s3->aead_read_ctx = aead_ctx;
@@ -120,7 +121,7 @@
}
static int ssl3_set_write_state(SSL *ssl, SSL_AEAD_CTX *aead_ctx) {
- memset(ssl->s3->write_sequence, 0, sizeof(ssl->s3->write_sequence));
+ OPENSSL_memset(ssl->s3->write_sequence, 0, sizeof(ssl->s3->write_sequence));
SSL_AEAD_CTX_free(ssl->s3->aead_write_ctx);
ssl->s3->aead_write_ctx = aead_ctx;
diff --git a/ssl/tls_record.c b/ssl/tls_record.c
index c52909c..9e04163 100644
--- a/ssl/tls_record.c
+++ b/ssl/tls_record.c
@@ -422,7 +422,7 @@
return 0;
}
- memmove(out + SSL3_RT_HEADER_LENGTH, in, in_len);
+ OPENSSL_memmove(out + SSL3_RT_HEADER_LENGTH, in, in_len);
out[SSL3_RT_HEADER_LENGTH + in_len] = type;
in = out + SSL3_RT_HEADER_LENGTH;
type = SSL3_RT_APPLICATION_DATA;
