diff --git a/ssl/d1_both.cc b/ssl/d1_both.cc
index 2b652d1..c7f85c7 100644
--- a/ssl/d1_both.cc
+++ b/ssl/d1_both.cc
@@ -437,10 +437,6 @@
 }
 
 bool dtls_has_unprocessed_handshake_data(const SSL *ssl) {
-  if (ssl->d1->has_change_cipher_spec) {
-    return true;
-  }
-
   size_t current = ssl->d1->handshake_read_seq % SSL_MAX_HANDSHAKE_FLIGHT;
   for (size_t i = 0; i < SSL_MAX_HANDSHAKE_FLIGHT; i++) {
     // Skip the current message.
diff --git a/ssl/dtls_method.cc b/ssl/dtls_method.cc
index 0ce7c1f..4b369b6 100644
--- a/ssl/dtls_method.cc
+++ b/ssl/dtls_method.cc
@@ -90,6 +90,7 @@
   OPENSSL_memset(ssl->s3->read_sequence, 0, sizeof(ssl->s3->read_sequence));
 
   ssl->s3->aead_read_ctx = std::move(aead_ctx);
+  ssl->d1->has_change_cipher_spec = 0;
   return true;
 }
 
