grpc 1.9.1 → 1.10.0.pre1

data/third_party/boringssl/ssl/{d1_srtp.c → d1_srtp.cc}

@@ -124,6 +124,8 @@
 #include "internal.h"
 
 
+using namespace bssl;
+
 static const SRTP_PROTECTION_PROFILE kSRTPProfiles[] = {
     {
         "SRTP_AES128_CM_SHA1_80", SRTP_AES128_CM_SHA1_80,
@@ -143,9 +145,7 @@ static const SRTP_PROTECTION_PROFILE kSRTPProfiles[] = {
 static int find_profile_by_name(const char *profile_name,
                                 const SRTP_PROTECTION_PROFILE **pptr,
                                 size_t len) {
-  const SRTP_PROTECTION_PROFILE *p;
-
-  p = kSRTPProfiles;
+  const SRTP_PROTECTION_PROFILE *p = kSRTPProfiles;
   while (p->name) {
     if (len == strlen(p->name) && !strncmp(p->name, profile_name, len)) {
       *pptr = p;
@@ -160,9 +160,9 @@ static int find_profile_by_name(const char *profile_name,
 
 static int ssl_ctx_make_profiles(const char *profiles_string,
                                  STACK_OF(SRTP_PROTECTION_PROFILE) **out) {
-  STACK_OF(SRTP_PROTECTION_PROFILE) *profiles =
-      sk_SRTP_PROTECTION_PROFILE_new_null();
-  if (profiles == NULL) {
+  UniquePtr<STACK_OF(SRTP_PROTECTION_PROFILE)> profiles(
+      sk_SRTP_PROTECTION_PROFILE_new_null());
+  if (profiles == nullptr) {
     OPENSSL_PUT_ERROR(SSL, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES);
     return 0;
   }
@@ -176,11 +176,11 @@ static int ssl_ctx_make_profiles(const char *profiles_string,
     if (!find_profile_by_name(ptr, &profile,
                               col ? (size_t)(col - ptr) : strlen(ptr))) {
       OPENSSL_PUT_ERROR(SSL, SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE);
-      goto err;
+      return 0;
     }
 
-    if (!sk_SRTP_PROTECTION_PROFILE_push(profiles, profile)) {
-      goto err;
+    if (!sk_SRTP_PROTECTION_PROFILE_push(profiles.get(), profile)) {
+      return 0;
     }
 
     if (col) {
@@ -189,12 +189,8 @@ static int ssl_ctx_make_profiles(const char *profiles_string,
   } while (col);
 
   sk_SRTP_PROTECTION_PROFILE_free(*out);
-  *out = profiles;
+  *out = profiles.release();
   return 1;
-
-err:
-  sk_SRTP_PROTECTION_PROFILE_free(profiles);
-  return 0;
 }
 
 int SSL_CTX_set_srtp_profiles(SSL_CTX *ctx, const char *profiles) {
@@ -226,11 +222,11 @@ const SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *ssl) {
 }
 
 int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles) {
-  /* This API inverts its return value. */
+  // This API inverts its return value.
   return !SSL_CTX_set_srtp_profiles(ctx, profiles);
 }
 
 int SSL_set_tlsext_use_srtp(SSL *ssl, const char *profiles) {
-  /* This API inverts its return value. */
+  // This API inverts its return value.
   return !SSL_set_srtp_profiles(ssl, profiles);
 }

data/third_party/boringssl/ssl/{dtls_method.c → dtls_method.cc}

@@ -66,49 +66,27 @@
 #include "internal.h"
 
 
-static int dtls1_version_from_wire(uint16_t *out_version,
-                                   uint16_t wire_version) {
-  switch (wire_version) {
-    case DTLS1_VERSION:
-      /* DTLS 1.0 maps to TLS 1.1, not TLS 1.0. */
-      *out_version = TLS1_1_VERSION;
-      return 1;
-    case DTLS1_2_VERSION:
-      *out_version = TLS1_2_VERSION;
-      return 1;
-  }
-
-  return 0;
-}
-
-static uint16_t dtls1_version_to_wire(uint16_t version) {
-  switch (version) {
-    case TLS1_1_VERSION:
-      /* DTLS 1.0 maps to TLS 1.1, not TLS 1.0. */
-      return DTLS1_VERSION;
-    case TLS1_2_VERSION:
-      return DTLS1_2_VERSION;
-  }
-
-  /* It is an error to use this function with an invalid version. */
-  assert(0);
-  return 0;
-}
+using namespace bssl;
 
 static int dtls1_supports_cipher(const SSL_CIPHER *cipher) {
   return cipher->algorithm_enc != SSL_eNULL;
 }
 
-static void dtls1_expect_flight(SSL *ssl) { dtls1_start_timer(ssl); }
-
-static void dtls1_received_flight(SSL *ssl) { dtls1_stop_timer(ssl); }
+static void dtls1_on_handshake_complete(SSL *ssl) {
+  // Stop the reply timer left by the last flight we sent.
+  dtls1_stop_timer(ssl);
+  // If the final flight had a reply, we know the peer has received it. If not,
+  // we must leave the flight around for post-handshake retransmission.
+  if (ssl->d1->flight_has_reply) {
+    dtls_clear_outgoing_messages(ssl);
+  }
+}
 
-static int dtls1_set_read_state(SSL *ssl, SSL_AEAD_CTX *aead_ctx) {
-  /* Cipher changes are illegal when there are buffered incoming messages. */
-  if (dtls_has_incoming_messages(ssl)) {
+static int dtls1_set_read_state(SSL *ssl, UniquePtr<SSLAEADContext> aead_ctx) {
+  // Cipher changes are illegal when there are buffered incoming messages.
+  if (dtls_has_incoming_messages(ssl) || ssl->d1->has_change_cipher_spec) {
     OPENSSL_PUT_ERROR(SSL, SSL_R_BUFFERED_MESSAGES_ON_CIPHER_CHANGE);
     ssl3_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
-    SSL_AEAD_CTX_free(aead_ctx);
     return 0;
   }
 
@@ -116,33 +94,30 @@ static int dtls1_set_read_state(SSL *ssl, SSL_AEAD_CTX *aead_ctx) {
   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;
+  Delete(ssl->s3->aead_read_ctx);
+  ssl->s3->aead_read_ctx = aead_ctx.release();
   return 1;
 }
 
-static int dtls1_set_write_state(SSL *ssl, SSL_AEAD_CTX *aead_ctx) {
+static int dtls1_set_write_state(SSL *ssl, UniquePtr<SSLAEADContext> aead_ctx) {
   ssl->d1->w_epoch++;
   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;
+  Delete(ssl->d1->last_aead_write_ctx);
+  ssl->d1->last_aead_write_ctx = ssl->s3->aead_write_ctx;
+  ssl->s3->aead_write_ctx = aead_ctx.release();
   return 1;
 }
 
 static const SSL_PROTOCOL_METHOD kDTLSProtocolMethod = {
     1 /* is_dtls */,
-    TLS1_1_VERSION,
-    TLS1_2_VERSION,
-    dtls1_version_from_wire,
-    dtls1_version_to_wire,
     dtls1_new,
     dtls1_free,
     dtls1_get_message,
-    dtls1_get_current_message,
-    dtls1_release_current_message,
+    dtls1_read_message,
+    dtls1_next_message,
     dtls1_read_app_data,
     dtls1_read_change_cipher_spec,
     dtls1_read_close_notify,
@@ -155,8 +130,7 @@ static const SSL_PROTOCOL_METHOD kDTLSProtocolMethod = {
     dtls1_add_change_cipher_spec,
     dtls1_add_alert,
     dtls1_flush_flight,
-    dtls1_expect_flight,
-    dtls1_received_flight,
+    dtls1_on_handshake_complete,
     dtls1_set_read_state,
     dtls1_set_write_state,
 };
@@ -170,7 +144,16 @@ const SSL_METHOD *DTLS_method(void) {
   return &kMethod;
 }
 
-/* Legacy version-locked methods. */
+const SSL_METHOD *DTLS_with_buffers_method(void) {
+  static const SSL_METHOD kMethod = {
+      0,
+      &kDTLSProtocolMethod,
+      &ssl_noop_x509_method,
+  };
+  return &kMethod;
+}
+
+// Legacy version-locked methods.
 
 const SSL_METHOD *DTLSv1_2_method(void) {
   static const SSL_METHOD kMethod = {
@@ -190,7 +173,7 @@ const SSL_METHOD *DTLSv1_method(void) {
   return &kMethod;
 }
 
-/* Legacy side-specific methods. */
+// Legacy side-specific methods.
 
 const SSL_METHOD *DTLSv1_2_server_method(void) {
   return DTLSv1_2_method();

data/third_party/boringssl/ssl/{dtls_record.c → dtls_record.cc}

@@ -121,8 +121,10 @@
 #include "../crypto/internal.h"
 
 
-/* to_u64_be treats |in| as a 8-byte big-endian integer and returns the value as
- * a |uint64_t|. */
+namespace bssl {
+
+// to_u64_be treats |in| as a 8-byte big-endian integer and returns the value as
+// a |uint64_t|.
 static uint64_t to_u64_be(const uint8_t in[8]) {
   uint64_t ret = 0;
   unsigned i;
@@ -133,8 +135,8 @@ static uint64_t to_u64_be(const uint8_t in[8]) {
   return ret;
 }
 
-/* dtls1_bitmap_should_discard returns one if |seq_num| has been seen in |bitmap|
- * or is stale. Otherwise it returns zero. */
+// dtls1_bitmap_should_discard returns one if |seq_num| has been seen in
+// |bitmap| or is stale. Otherwise it returns zero.
 static int dtls1_bitmap_should_discard(DTLS1_BITMAP *bitmap,
                                        const uint8_t seq_num[8]) {
   const unsigned kWindowSize = sizeof(bitmap->map) * 8;
@@ -147,15 +149,15 @@ static int dtls1_bitmap_should_discard(DTLS1_BITMAP *bitmap,
   return idx >= kWindowSize || (bitmap->map & (((uint64_t)1) << idx));
 }
 
-/* dtls1_bitmap_record updates |bitmap| to record receipt of sequence number
- * |seq_num|. It slides the window forward if needed. It is an error to call
- * this function on a stale sequence number. */
+// dtls1_bitmap_record updates |bitmap| to record receipt of sequence number
+// |seq_num|. It slides the window forward if needed. It is an error to call
+// this function on a stale sequence number.
 static void dtls1_bitmap_record(DTLS1_BITMAP *bitmap,
                                 const uint8_t seq_num[8]) {
   const unsigned kWindowSize = sizeof(bitmap->map) * 8;
 
   uint64_t seq_num_u = to_u64_be(seq_num);
-  /* Shift the window if necessary. */
+  // Shift the window if necessary.
   if (seq_num_u > bitmap->max_seq_num) {
     uint64_t shift = seq_num_u - bitmap->max_seq_num;
     if (shift >= kWindowSize) {
@@ -172,16 +174,15 @@ static void dtls1_bitmap_record(DTLS1_BITMAP *bitmap,
   }
 }
 
-enum ssl_open_record_t dtls_open_record(SSL *ssl, uint8_t *out_type, CBS *out,
+enum ssl_open_record_t dtls_open_record(SSL *ssl, uint8_t *out_type,
+                                        Span<uint8_t> *out,
                                         size_t *out_consumed,
-                                        uint8_t *out_alert, uint8_t *in,
-                                        size_t in_len) {
+                                        uint8_t *out_alert, Span<uint8_t> in) {
   *out_consumed = 0;
 
-  CBS cbs;
-  CBS_init(&cbs, in, in_len);
+  CBS cbs = CBS(in);
 
-  /* Decode the record. */
+  // Decode the record.
   uint8_t type;
   uint16_t version;
   uint8_t sequence[8];
@@ -190,45 +191,59 @@ enum ssl_open_record_t dtls_open_record(SSL *ssl, uint8_t *out_type, CBS *out,
       !CBS_get_u16(&cbs, &version) ||
       !CBS_copy_bytes(&cbs, sequence, 8) ||
       !CBS_get_u16_length_prefixed(&cbs, &body) ||
-      (ssl->s3->have_version && version != ssl->version) ||
-      (version >> 8) != DTLS1_VERSION_MAJOR ||
       CBS_len(&body) > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
-    /* The record header was incomplete or malformed. Drop the entire packet. */
-    *out_consumed = in_len;
+    // The record header was incomplete or malformed. Drop the entire packet.
+    *out_consumed = in.size();
+    return ssl_open_record_discard;
+  }
+
+  bool version_ok;
+  if (ssl->s3->aead_read_ctx->is_null_cipher()) {
+    // Only check the first byte. Enforcing beyond that can prevent decoding
+    // version negotiation failure alerts.
+    version_ok = (version >> 8) == DTLS1_VERSION_MAJOR;
+  } else {
+    version_ok = version == ssl->s3->aead_read_ctx->RecordVersion();
+  }
+
+  if (!version_ok) {
+    // The record header was incomplete or malformed. Drop the entire packet.
+    *out_consumed = in.size();
     return ssl_open_record_discard;
   }
 
-  ssl_do_msg_callback(ssl, 0 /* read */, SSL3_RT_HEADER, in,
-                      DTLS1_RT_HEADER_LENGTH);
+  ssl_do_msg_callback(ssl, 0 /* read */, SSL3_RT_HEADER,
+                      in.subspan(0, DTLS1_RT_HEADER_LENGTH));
 
   uint16_t epoch = (((uint16_t)sequence[0]) << 8) | sequence[1];
   if (epoch != ssl->d1->r_epoch ||
       dtls1_bitmap_should_discard(&ssl->d1->bitmap, sequence)) {
-    /* Drop this record. It's from the wrong epoch or is a replay. Note that if
-     * |epoch| is the next epoch, the record could be buffered for later. For
-     * simplicity, drop it and expect retransmit to handle it later; DTLS must
-     * handle packet loss anyway. */
-    *out_consumed = in_len - CBS_len(&cbs);
+    // Drop this record. It's from the wrong epoch or is a replay. Note that if
+    // |epoch| is the next epoch, the record could be buffered for later. For
+    // simplicity, drop it and expect retransmit to handle it later; DTLS must
+    // handle packet loss anyway.
+    *out_consumed = in.size() - CBS_len(&cbs);
     return ssl_open_record_discard;
   }
 
-  /* Decrypt the body in-place. */
-  if (!SSL_AEAD_CTX_open(ssl->s3->aead_read_ctx, out, type, version, sequence,
-                         (uint8_t *)CBS_data(&body), CBS_len(&body))) {
-    /* Bad packets are silently dropped in DTLS. See section 4.2.1 of RFC 6347.
-     * Clear the error queue of any errors decryption may have added. Drop the
-     * entire packet as it must not have come from the peer.
-     *
-     * TODO(davidben): This doesn't distinguish malloc failures from encryption
-     * failures. */
+  // discard the body in-place.
+  if (!ssl->s3->aead_read_ctx->Open(
+          out, type, version, sequence,
+          MakeSpan(const_cast<uint8_t *>(CBS_data(&body)), CBS_len(&body)))) {
+    // Bad packets are silently dropped in DTLS. See section 4.2.1 of RFC 6347.
+    // Clear the error queue of any errors decryption may have added. Drop the
+    // entire packet as it must not have come from the peer.
+    //
+    // TODO(davidben): This doesn't distinguish malloc failures from encryption
+    // failures.
     ERR_clear_error();
-    *out_consumed = in_len - CBS_len(&cbs);
+    *out_consumed = in.size() - CBS_len(&cbs);
     return ssl_open_record_discard;
   }
-  *out_consumed = in_len - CBS_len(&cbs);
+  *out_consumed = in.size() - CBS_len(&cbs);
 
-  /* Check the plaintext length. */
-  if (CBS_len(out) > SSL3_RT_MAX_PLAIN_LENGTH) {
+  // Check the plaintext length.
+  if (out->size() > SSL3_RT_MAX_PLAIN_LENGTH) {
     OPENSSL_PUT_ERROR(SSL, SSL_R_DATA_LENGTH_TOO_LONG);
     *out_alert = SSL_AD_RECORD_OVERFLOW;
     return ssl_open_record_error;
@@ -236,11 +251,11 @@ enum ssl_open_record_t dtls_open_record(SSL *ssl, uint8_t *out_type, CBS *out,
 
   dtls1_bitmap_record(&ssl->d1->bitmap, sequence);
 
-  /* TODO(davidben): Limit the number of empty records as in TLS? This is only
-   * useful if we also limit discarded packets. */
+  // TODO(davidben): Limit the number of empty records as in TLS? This is only
+  // useful if we also limit discarded packets.
 
   if (type == SSL3_RT_ALERT) {
-    return ssl_process_alert(ssl, out_alert, CBS_data(out), CBS_len(out));
+    return ssl_process_alert(ssl, out_alert, *out);
   }
 
   ssl->s3->warning_alert_count = 0;
@@ -249,13 +264,11 @@ enum ssl_open_record_t dtls_open_record(SSL *ssl, uint8_t *out_type, CBS *out,
   return ssl_open_record_success;
 }
 
-static const SSL_AEAD_CTX *get_write_aead(const SSL *ssl,
-                                          enum dtls1_use_epoch_t use_epoch) {
+static const SSLAEADContext *get_write_aead(const SSL *ssl,
+                                            enum dtls1_use_epoch_t use_epoch) {
   if (use_epoch == dtls1_use_previous_epoch) {
-    /* DTLS renegotiation is unsupported, so only epochs 0 (NULL cipher) and 1
-     * (negotiated cipher) exist. */
-    assert(ssl->d1->w_epoch == 1);
-    return NULL;
+    assert(ssl->d1->w_epoch >= 1);
+    return ssl->d1->last_aead_write_ctx;
   }
 
   return ssl->s3->aead_write_ctx;
@@ -263,13 +276,12 @@ static const SSL_AEAD_CTX *get_write_aead(const SSL *ssl,
 
 size_t dtls_max_seal_overhead(const SSL *ssl,
                               enum dtls1_use_epoch_t use_epoch) {
-  return DTLS1_RT_HEADER_LENGTH +
-         SSL_AEAD_CTX_max_overhead(get_write_aead(ssl, use_epoch));
+  return DTLS1_RT_HEADER_LENGTH + get_write_aead(ssl, use_epoch)->MaxOverhead();
 }
 
 size_t dtls_seal_prefix_len(const SSL *ssl, enum dtls1_use_epoch_t use_epoch) {
   return DTLS1_RT_HEADER_LENGTH +
-         SSL_AEAD_CTX_explicit_nonce_len(get_write_aead(ssl, use_epoch));
+         get_write_aead(ssl, use_epoch)->ExplicitNonceLen();
 }
 
 int dtls_seal_record(SSL *ssl, uint8_t *out, size_t *out_len, size_t max_out,
@@ -282,16 +294,14 @@ int dtls_seal_record(SSL *ssl, uint8_t *out, size_t *out_len, size_t max_out,
     return 0;
   }
 
-  /* Determine the parameters for the current epoch. */
+  // Determine the parameters for the current epoch.
   uint16_t epoch = ssl->d1->w_epoch;
-  SSL_AEAD_CTX *aead = ssl->s3->aead_write_ctx;
+  SSLAEADContext *aead = ssl->s3->aead_write_ctx;
   uint8_t *seq = ssl->s3->write_sequence;
   if (use_epoch == dtls1_use_previous_epoch) {
-    /* DTLS renegotiation is unsupported, so only epochs 0 (NULL cipher) and 1
-     * (negotiated cipher) exist. */
-    assert(ssl->d1->w_epoch == 1);
+    assert(ssl->d1->w_epoch >= 1);
     epoch = ssl->d1->w_epoch - 1;
-    aead = NULL;
+    aead = ssl->d1->last_aead_write_ctx;
     seq = ssl->d1->last_write_sequence;
   }
 
@@ -302,18 +312,18 @@ int dtls_seal_record(SSL *ssl, uint8_t *out, size_t *out_len, size_t max_out,
 
   out[0] = type;
 
-  uint16_t wire_version = ssl->s3->have_version ? ssl->version : DTLS1_VERSION;
-  out[1] = wire_version >> 8;
-  out[2] = wire_version & 0xff;
+  uint16_t record_version = ssl->s3->aead_write_ctx->RecordVersion();
+  out[1] = record_version >> 8;
+  out[2] = record_version & 0xff;
 
   out[3] = epoch >> 8;
   out[4] = epoch & 0xff;
   OPENSSL_memcpy(&out[5], &seq[2], 6);
 
   size_t ciphertext_len;
-  if (!SSL_AEAD_CTX_seal(aead, out + DTLS1_RT_HEADER_LENGTH, &ciphertext_len,
-                         max_out - DTLS1_RT_HEADER_LENGTH, type, wire_version,
-                         &out[3] /* seq */, in, in_len) ||
+  if (!aead->Seal(out + DTLS1_RT_HEADER_LENGTH, &ciphertext_len,
+                  max_out - DTLS1_RT_HEADER_LENGTH, type, record_version,
+                  &out[3] /* seq */, in, in_len) ||
       !ssl_record_sequence_update(&seq[2], 6)) {
     return 0;
   }
@@ -327,8 +337,10 @@ int dtls_seal_record(SSL *ssl, uint8_t *out, size_t *out_len, size_t max_out,
 
   *out_len = DTLS1_RT_HEADER_LENGTH + ciphertext_len;
 
-  ssl_do_msg_callback(ssl, 1 /* write */, SSL3_RT_HEADER, out,
-                      DTLS1_RT_HEADER_LENGTH);
+  ssl_do_msg_callback(ssl, 1 /* write */, SSL3_RT_HEADER,
+                      MakeSpan(out, DTLS1_RT_HEADER_LENGTH));
 
   return 1;
 }
+
+}  // namespace bssl