grpc 1.69.0 → 1.70.1

data/third_party/boringssl-with-bazel/src/ssl/dtls_method.cc

@@ -68,19 +68,51 @@
 using namespace bssl;
 
 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);
+  if (ssl_protocol_version(ssl) <= TLS1_2_VERSION) {
+    // Stop the reply timer left by the last flight we sent. In DTLS 1.2, the
+    // retransmission timer ends when the handshake completes. If we sent the
+    // final flight, we may still need to retransmit it, but that is driven by
+    // messages from the peer.
+    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 bool next_epoch(const SSL *ssl, uint16_t *out,
+                       ssl_encryption_level_t level, uint16_t prev) {
+  switch (level) {
+    case ssl_encryption_initial:
+    case ssl_encryption_early_data:
+    case ssl_encryption_handshake:
+      *out = static_cast<uint16_t>(level);
+      return true;
+
+    case ssl_encryption_application:
+      if (prev < ssl_encryption_application &&
+          ssl_protocol_version(ssl) >= TLS1_3_VERSION) {
+        *out = static_cast<uint16_t>(level);
+        return true;
+      }
+
+      if (prev == 0xffff) {
+        OPENSSL_PUT_ERROR(SSL, SSL_R_TOO_MANY_KEY_UPDATES);
+        return false;
+      }
+      *out = prev + 1;
+      return true;
+  }
+
+  assert(0);
+  return false;
+}
+
 static bool dtls1_set_read_state(SSL *ssl, ssl_encryption_level_t level,
                                  UniquePtr<SSLAEADContext> aead_ctx,
-                                 Span<const uint8_t> secret_for_quic) {
-  assert(secret_for_quic.empty());  // QUIC does not use DTLS.
+                                 Span<const uint8_t> traffic_secret) {
   // Cipher changes are forbidden if the current epoch has leftover data.
   if (dtls_has_unprocessed_handshake_data(ssl)) {
     OPENSSL_PUT_ERROR(SSL, SSL_R_EXCESS_HANDSHAKE_DATA);
@@ -88,39 +120,62 @@ static bool dtls1_set_read_state(SSL *ssl, ssl_encryption_level_t level,
     return false;
   }
 
+  DTLSReadEpoch new_epoch;
+  new_epoch.aead = std::move(aead_ctx);
+  if (!next_epoch(ssl, &new_epoch.epoch, level, ssl->d1->read_epoch.epoch)) {
+    ssl_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
+    return false;
+  }
+
   if (ssl_protocol_version(ssl) > TLS1_2_VERSION) {
-    // TODO(crbug.com/boringssl/715): Handle the additional epochs used for key
-    // update.
-    // TODO(crbug.com/boringssl/715): If we want to gracefully handle packet
-    // reordering around KeyUpdate (i.e. accept records from both epochs), we'll
-    // need a separate bitmap for each epoch.
-    ssl->d1->r_epoch = level;
+    new_epoch.rn_encrypter =
+        RecordNumberEncrypter::Create(new_epoch.aead->cipher(), traffic_secret);
+    if (new_epoch.rn_encrypter == nullptr) {
+      return false;
+    }
+
+    // In DTLS 1.3, new read epochs are not applied immediately. In principle,
+    // we could do the same in DTLS 1.2, but we would ignore every record from
+    // the previous epoch anyway.
+    assert(ssl->d1->next_read_epoch == nullptr);
+    ssl->d1->next_read_epoch = MakeUnique<DTLSReadEpoch>(std::move(new_epoch));
+    if (ssl->d1->next_read_epoch == nullptr) {
+      return false;
+    }
   } else {
-    ssl->d1->r_epoch++;
+    ssl->d1->read_epoch = std::move(new_epoch);
+    ssl->d1->has_change_cipher_spec = false;
   }
-  ssl->d1->bitmap = DTLS1_BITMAP();
-  ssl->s3->read_sequence = 0;
-
-  ssl->s3->aead_read_ctx = std::move(aead_ctx);
-  ssl->s3->read_level = level;
-  ssl->d1->has_change_cipher_spec = false;
   return true;
 }
 
 static bool dtls1_set_write_state(SSL *ssl, ssl_encryption_level_t level,
                                   UniquePtr<SSLAEADContext> aead_ctx,
-                                  Span<const uint8_t> secret_for_quic) {
-  assert(secret_for_quic.empty());  // QUIC does not use DTLS.
-  ssl->d1->w_epoch++;
-  ssl->d1->last_write_sequence = ssl->s3->write_sequence;
-  ssl->s3->write_sequence = 0;
+                                  Span<const uint8_t> traffic_secret) {
+  uint16_t epoch;
+  if (!next_epoch(ssl, &epoch, level, ssl->d1->write_epoch.epoch())) {
+    return false;
+  }
 
+  DTLSWriteEpoch new_epoch;
+  new_epoch.aead = std::move(aead_ctx);
+  new_epoch.next_record = DTLSRecordNumber(epoch, 0);
   if (ssl_protocol_version(ssl) > TLS1_2_VERSION) {
-    ssl->d1->w_epoch = level;
+    new_epoch.rn_encrypter =
+        RecordNumberEncrypter::Create(new_epoch.aead->cipher(), traffic_secret);
+    if (new_epoch.rn_encrypter == nullptr) {
+      return false;
+    }
+  }
+
+  auto current = MakeUnique<DTLSWriteEpoch>(std::move(ssl->d1->write_epoch));
+  if (current == nullptr) {
+    return false;
   }
-  ssl->d1->last_aead_write_ctx = std::move(ssl->s3->aead_write_ctx);
-  ssl->s3->aead_write_ctx = std::move(aead_ctx);
-  ssl->s3->write_level = level;
+
+  ssl->d1->write_epoch = std::move(new_epoch);
+  ssl->d1->extra_write_epochs.PushBack(std::move(current));
+  dtls_clear_unused_write_epochs(ssl);
   return true;
 }
 
@@ -140,7 +195,9 @@ static const SSL_PROTOCOL_METHOD kDTLSProtocolMethod = {
     dtls1_finish_message,
     dtls1_add_message,
     dtls1_add_change_cipher_spec,
-    dtls1_flush_flight,
+    dtls1_finish_flight,
+    dtls1_schedule_ack,
+    dtls1_flush,
     dtls1_on_handshake_complete,
     dtls1_set_read_state,
     dtls1_set_write_state,
@@ -186,26 +243,14 @@ const SSL_METHOD *DTLSv1_method(void) {
 
 // Legacy side-specific methods.
 
-const SSL_METHOD *DTLSv1_2_server_method(void) {
-  return DTLSv1_2_method();
-}
+const SSL_METHOD *DTLSv1_2_server_method(void) { return DTLSv1_2_method(); }
 
-const SSL_METHOD *DTLSv1_server_method(void) {
-  return DTLSv1_method();
-}
+const SSL_METHOD *DTLSv1_server_method(void) { return DTLSv1_method(); }
 
-const SSL_METHOD *DTLSv1_2_client_method(void) {
-  return DTLSv1_2_method();
-}
+const SSL_METHOD *DTLSv1_2_client_method(void) { return DTLSv1_2_method(); }
 
-const SSL_METHOD *DTLSv1_client_method(void) {
-  return DTLSv1_method();
-}
+const SSL_METHOD *DTLSv1_client_method(void) { return DTLSv1_method(); }
 
-const SSL_METHOD *DTLS_server_method(void) {
-  return DTLS_method();
-}
+const SSL_METHOD *DTLS_server_method(void) { return DTLS_method(); }
 
-const SSL_METHOD *DTLS_client_method(void) {
-  return DTLS_method();
-}
+const SSL_METHOD *DTLS_client_method(void) { return DTLS_method(); }