Relanding: Allow the DTLS fingerprint verification to occur after the handshake.

webrtc/p2p/base/dtlstransportchannel.cc

 /*
  *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 161 matching lines @@
     LOG(LS_ERROR) << "Not changing max. protocol version "
                   << "while DTLS is negotiating";
     return false;
   }
 
   ssl_max_version_ = version;
   return true;
 }
 
 bool DtlsTransportChannelWrapper::SetSslRole(rtc::SSLRole role) {
-  if (dtls_state() == DTLS_TRANSPORT_CONNECTED) {
+  if (dtls_) {
     if (ssl_role_ != role) {
       LOG(LS_ERROR) << "SSL Role can't be reversed after the session is setup.";
       return false;
     }
     return true;
   }
 
   ssl_role_ = role;
   return true;
 }
@@ skipping 35 matching lines @@
   }
 
   // Otherwise, we must have a local certificate before setting remote
   // fingerprint.
   if (!dtls_active_) {
     LOG_J(LS_ERROR, this) << "Can't set DTLS remote settings in this state.";
     return false;
   }
 
   // At this point we know we are doing DTLS
+  bool fingerprint_changing = remote_fingerprint_value_.size() > 0u;
   remote_fingerprint_value_ = std::move(remote_fingerprint_value);
   remote_fingerprint_algorithm_ = digest_alg;
 
-  if (dtls_) {
+  // If the fingerprint is changing, start a completely new DTLS association.
+  if (dtls_ && fingerprint_changing) {
     // If the fingerprint is changing, we'll tear down the DTLS association and
     // create a new one, resetting our state.
     dtls_.reset(nullptr);
     set_dtls_state(DTLS_TRANSPORT_NEW);
     set_writable(false);
   }
 
-  if (!SetupDtls()) {
-    set_dtls_state(DTLS_TRANSPORT_FAILED);
-    return false;
+  if (dtls_) {
+    // This can occur if DTLS is set up before a remote fingerprint is
+    // received. For instance, if we set up DTLS due to receiving an early
+    // ClientHello.
+    if (!dtls_->SetPeerCertificateDigest(
+            remote_fingerprint_algorithm_,
+            reinterpret_cast<unsigned char*>(remote_fingerprint_value_.data()),
+            remote_fingerprint_value_.size())) {
+      LOG_J(LS_ERROR, this) << "Couldn't set DTLS certificate digest.";

[mattdr-at-webrtc.org, 2016/07/20 00:50:27]

should we set DTLS state here too?

[Taylor Brandstetter, 2016/07/20 17:36:52]

If this has an immediate effect and succeeds, we'll asynchronously see "SE_OPEN"
in OnDtlsEvent and that will update the state. But if it fails we'll see no such
event and should update the state here. Good catch.

I should probably update the unit tests adding another dimension: whether or not
the fingerprint is valid. If I had done that earlier I would have caught this
problem.

+      return false;
+    }
+  } else {
+    if (!SetupDtls()) {
+      set_dtls_state(DTLS_TRANSPORT_FAILED);
+      return false;
+    }
   }
 
   return true;
 }
 
 std::unique_ptr<rtc::SSLCertificate>
 DtlsTransportChannelWrapper::GetRemoteSSLCertificate() const {
   if (!dtls_) {
     return nullptr;
   }
@@ skipping 11 matching lines @@
     return false;
   }
 
   downward_ = downward;
 
   dtls_->SetIdentity(local_certificate_->identity()->GetReference());
   dtls_->SetMode(rtc::SSL_MODE_DTLS);
   dtls_->SetMaxProtocolVersion(ssl_max_version_);
   dtls_->SetServerRole(ssl_role_);
   dtls_->SignalEvent.connect(this, &DtlsTransportChannelWrapper::OnDtlsEvent);
-  if (!dtls_->SetPeerCertificateDigest(
+  if (remote_fingerprint_value_.size() &&
+      !dtls_->SetPeerCertificateDigest(
           remote_fingerprint_algorithm_,
           reinterpret_cast<unsigned char*>(remote_fingerprint_value_.data()),
           remote_fingerprint_value_.size())) {
     LOG_J(LS_ERROR, this) << "Couldn't set DTLS certificate digest.";
     return false;
   }
 
   // Set up DTLS-SRTP, if it's been enabled.
   if (!srtp_ciphers_.empty()) {
     if (!dtls_->SetDtlsSrtpCryptoSuites(srtp_ciphers_)) {
@@ skipping 98 matching lines @@
     case DTLS_TRANSPORT_FAILED:
     case DTLS_TRANSPORT_CLOSED:
       // Can't send anything when we're closed.
       return -1;
     default:
       ASSERT(false);
       return -1;
   }
 }
 
+bool DtlsTransportChannelWrapper::IsDtlsConnected() {
+  return dtls_ && dtls_->IsTlsConnected();
+}
+
 // The state transition logic here is as follows:
 // (1) If we're not doing DTLS-SRTP, then the state is just the
 //     state of the underlying impl()
 // (2) If we're doing DTLS-SRTP:
 //     - Prior to the DTLS handshake, the state is neither receiving nor
 //       writable
 //     - When the impl goes writable for the first time we
 //       start the DTLS handshake
 //     - Once the DTLS handshake completes, the state is that of the
 //       impl again
@@ skipping 60 matching lines @@
         LOG_J(LS_INFO, this) << "Packet received before DTLS started.";
       } else {
         LOG_J(LS_WARNING, this) << "Packet received before we know if we are "
                                 << "doing DTLS or not.";
       }
       // Cache a client hello packet received before DTLS has actually started.
       if (IsDtlsClientHelloPacket(data, size)) {
         LOG_J(LS_INFO, this) << "Caching DTLS ClientHello packet until DTLS is "
                              << "started.";
         cached_client_hello_.SetData(data, size);
+        // If we haven't started setting up DTLS yet (because we don't have a
+        // remote fingerprint/role), we can use the client hello as a clue that
+        // the peer has chosen the client role, and proceed with the handshake.
+        // The fingerprint will be verified when it's set.
+        if (!dtls_ && local_certificate_) {

[mattdr-at-webrtc.org, 2016/07/20 00:50:27]

What does checking local_certificate protect against?

[Taylor Brandstetter, 2016/07/20 17:36:52]

SetupDtls requires the local certificate. You might then wonder, "What happens
if we receive a client hello, *then* get our local certificate? Should we call
SetupDtls then?" However this is currently not possible under the PeerConnection
offer/answer model, so I'm not concerned about this optimization yet.

+          SetSslRole(rtc::SSL_SERVER);
+          SetupDtls();
+        }
       } else {
         LOG_J(LS_INFO, this) << "Not a DTLS ClientHello packet; dropping.";
       }
       break;
 
     case DTLS_TRANSPORT_CONNECTING:
     case DTLS_TRANSPORT_CONNECTED:
       // We should only get DTLS or SRTP packets; STUN's already been demuxed.
       // Is this potentially a DTLS packet?
       if (IsDtlsPacket(data, size)) {
@@ skipping 178 matching lines @@
                                      last_sent_packet_id, ready_to_send);
 }
 
 void DtlsTransportChannelWrapper::OnChannelStateChanged(
     TransportChannelImpl* channel) {
   ASSERT(channel == channel_);
   SignalStateChanged(this);
 }
 
 }  // namespace cricket