Implement GetChain for OpenSSLCertificate.

webrtc/rtc_base/opensslstreamadapter.cc

 /*
  *  Copyright 2004 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 19 matching lines @@
 #include "webrtc/rtc_base/openssladapter.h"
 #include "webrtc/rtc_base/openssldigest.h"
 #include "webrtc/rtc_base/opensslidentity.h"
 #include "webrtc/rtc_base/safe_conversions.h"
 #include "webrtc/rtc_base/stream.h"
 #include "webrtc/rtc_base/stringutils.h"
 #include "webrtc/rtc_base/thread.h"
 #include "webrtc/rtc_base/timeutils.h"
 
 namespace {
-  bool g_use_time_callback_for_testing = false;
+bool g_use_time_callback_for_testing = false;
 }
 
 namespace rtc {
 
 #if (OPENSSL_VERSION_NUMBER < 0x10001000L)
 #error "webrtc requires at least OpenSSL version 1.0.1, to support DTLS-SRTP"
 #endif
 
 // SRTP cipher suite table. |internal_name| is used to construct a
 // colon-separated profile strings which is needed by
@@ skipping 19 matching lines @@
   out_clock->tv_usec = (time % kNumNanosecsPerSec) / kNumNanosecsPerMicrosec;
 }
 #else  // #ifdef OPENSSL_IS_BORINGSSL
 
 // Cipher name table. Maps internal OpenSSL cipher ids to the RFC name.
 struct SslCipherMapEntry {
   uint32_t openssl_id;
   const char* rfc_name;
 };
 
-#define DEFINE_CIPHER_ENTRY_SSL3(name)  {SSL3_CK_##name, "TLS_"#name}
-#define DEFINE_CIPHER_ENTRY_TLS1(name)  {TLS1_CK_##name, "TLS_"#name}
+#define DEFINE_CIPHER_ENTRY_SSL3(name) \
+  { SSL3_CK_##name, "TLS_" #name }
+#define DEFINE_CIPHER_ENTRY_TLS1(name) \
+  { TLS1_CK_##name, "TLS_" #name }
 
 // There currently is no method available to get a RFC-compliant name for a
 // cipher suite from BoringSSL, so we need to define the mapping manually here.
 // This should go away once BoringSSL supports "SSL_CIPHER_standard_name"
 // (as available in OpenSSL if compiled with tracing enabled) or a similar
 // method.
 static const SslCipherMapEntry kSslCipherMap[] = {
     // TLS v1.0 ciphersuites from RFC2246.
     DEFINE_CIPHER_ENTRY_SSL3(RSA_RC4_128_SHA),
     {SSL3_CK_RSA_DES_192_CBC3_SHA, "TLS_RSA_WITH_3DES_EDE_CBC_SHA"},
@@ skipping 72 matching lines @@
 static long stream_ctrl(BIO* h, int cmd, long arg1, void* arg2);
 static int stream_new(BIO* h);
 static int stream_free(BIO* data);
 
 // TODO(davidben): This should be const once BoringSSL is assumed.
 static BIO_METHOD methods_stream = {
     BIO_TYPE_BIO, "stream",   stream_write, stream_read, stream_puts, 0,
     stream_ctrl,  stream_new, stream_free,  nullptr,
 };
 
-static BIO_METHOD* BIO_s_stream() { return(&methods_stream); }
+static BIO_METHOD* BIO_s_stream() {
+  return (&methods_stream);
+}
 
 static BIO* BIO_new_stream(StreamInterface* stream) {
   BIO* ret = BIO_new(BIO_s_stream());
   if (ret == nullptr)
     return nullptr;
   ret->ptr = stream;
   return ret;
 }
 
 // bio methods return 1 (or at least non-zero) on success and 0 on failure.
@@ skipping 267 matching lines @@
 
   srtp_ciphers_ = internal_ciphers;
   return true;
 }
 
 bool OpenSSLStreamAdapter::GetDtlsSrtpCryptoSuite(int* crypto_suite) {
   RTC_DCHECK(state_ == SSL_CONNECTED);
   if (state_ != SSL_CONNECTED)
     return false;
 
-  const SRTP_PROTECTION_PROFILE *srtp_profile =
+  const SRTP_PROTECTION_PROFILE* srtp_profile =
       SSL_get_selected_srtp_profile(ssl_);
 
   if (!srtp_profile)
     return false;
 
   *crypto_suite = srtp_profile->id;
   RTC_DCHECK(!SrtpCryptoSuiteToName(*crypto_suite).empty());
   return true;
 }
 
@@ skipping 24 matching lines @@
 void OpenSSLStreamAdapter::SetMode(SSLMode mode) {
   RTC_DCHECK(state_ == SSL_NONE);
   ssl_mode_ = mode;
 }
 
 void OpenSSLStreamAdapter::SetMaxProtocolVersion(SSLProtocolVersion version) {
   RTC_DCHECK(ssl_ctx_ == nullptr);
   ssl_max_version_ = version;
 }
 
-void OpenSSLStreamAdapter::SetInitialRetransmissionTimeout(
-    int timeout_ms) {
+void OpenSSLStreamAdapter::SetInitialRetransmissionTimeout(int timeout_ms) {
   RTC_DCHECK(ssl_ctx_ == nullptr);
   dtls_handshake_timeout_ms_ = timeout_ms;
 }
 
 //
 // StreamInterface Implementation
 //
 
-StreamResult OpenSSLStreamAdapter::Write(const void* data, size_t data_len,
-                                         size_t* written, int* error) {
+StreamResult OpenSSLStreamAdapter::Write(const void* data,
+                                         size_t data_len,
+                                         size_t* written,
+                                         int* error) {
   LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::Write(" << data_len << ")";
 
   switch (state_) {
-  case SSL_NONE:
-    // pass-through in clear text
-    return StreamAdapterInterface::Write(data, data_len, written, error);
+    case SSL_NONE:
+      // pass-through in clear text
+      return StreamAdapterInterface::Write(data, data_len, written, error);
 
-  case SSL_WAIT:
-  case SSL_CONNECTING:
-    return SR_BLOCK;
+    case SSL_WAIT:
+    case SSL_CONNECTING:
+      return SR_BLOCK;
 
-  case SSL_CONNECTED:
-    if (waiting_to_verify_peer_certificate()) {
-      return SR_BLOCK;
-    }
-    break;
+    case SSL_CONNECTED:
+      if (waiting_to_verify_peer_certificate()) {
+        return SR_BLOCK;
+      }
+      break;
 
-  case SSL_ERROR:
-  case SSL_CLOSED:
-  default:
-    if (error)
-      *error = ssl_error_code_;
-    return SR_ERROR;
+    case SSL_ERROR:
+    case SSL_CLOSED:
+    default:
+      if (error)
+        *error = ssl_error_code_;
+      return SR_ERROR;
   }
 
   // OpenSSL will return an error if we try to write zero bytes
   if (data_len == 0) {
     if (written)
       *written = 0;
     return SR_SUCCESS;
   }
 
   ssl_write_needs_read_ = false;
 
   int code = SSL_write(ssl_, data, checked_cast<int>(data_len));
   int ssl_error = SSL_get_error(ssl_, code);
   switch (ssl_error) {
-  case SSL_ERROR_NONE:
-    LOG(LS_VERBOSE) << " -- success";
-    RTC_DCHECK(0 < code && static_cast<unsigned>(code) <= data_len);
-    if (written)
-      *written = code;
-    return SR_SUCCESS;
-  case SSL_ERROR_WANT_READ:
-    LOG(LS_VERBOSE) << " -- error want read";
-    ssl_write_needs_read_ = true;
-    return SR_BLOCK;
-  case SSL_ERROR_WANT_WRITE:
-    LOG(LS_VERBOSE) << " -- error want write";
-    return SR_BLOCK;
+    case SSL_ERROR_NONE:
+      LOG(LS_VERBOSE) << " -- success";
+      RTC_DCHECK(0 < code && static_cast<unsigned>(code) <= data_len);
+      if (written)
+        *written = code;
+      return SR_SUCCESS;
+    case SSL_ERROR_WANT_READ:
+      LOG(LS_VERBOSE) << " -- error want read";
+      ssl_write_needs_read_ = true;
+      return SR_BLOCK;
+    case SSL_ERROR_WANT_WRITE:
+      LOG(LS_VERBOSE) << " -- error want write";
+      return SR_BLOCK;
 
-  case SSL_ERROR_ZERO_RETURN:
-  default:
-    Error("SSL_write", (ssl_error ? ssl_error : -1), 0, false);
-    if (error)
-      *error = ssl_error_code_;
-    return SR_ERROR;
+    case SSL_ERROR_ZERO_RETURN:
+    default:
+      Error("SSL_write", (ssl_error ? ssl_error : -1), 0, false);
+      if (error)
+        *error = ssl_error_code_;
+      return SR_ERROR;
   }
   // not reached
 }
 
-StreamResult OpenSSLStreamAdapter::Read(void* data, size_t data_len,
-                                        size_t* read, int* error) {
+StreamResult OpenSSLStreamAdapter::Read(void* data,
+                                        size_t data_len,
+                                        size_t* read,
+                                        int* error) {
   LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::Read(" << data_len << ")";
   switch (state_) {
     case SSL_NONE:
       // pass-through in clear text
       return StreamAdapterInterface::Read(data, data_len, read, error);
 
     case SSL_WAIT:
     case SSL_CONNECTING:
       return SR_BLOCK;
 
@@ skipping 106 matching lines @@
       if (waiting_to_verify_peer_certificate()) {
         return SS_OPENING;
       }
       return SS_OPEN;
     default:
       return SS_CLOSED;
   };
   // not reached
 }
 
-void OpenSSLStreamAdapter::OnEvent(StreamInterface* stream, int events,
+void OpenSSLStreamAdapter::OnEvent(StreamInterface* stream,
+                                   int events,
                                    int err) {
   int events_to_signal = 0;
   int signal_error = 0;
   RTC_DCHECK(stream == this->stream());
   if ((events & SE_OPEN)) {
     LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent SE_OPEN";
     if (state_ != SSL_WAIT) {
       RTC_DCHECK(state_ == SSL_NONE);
       events_to_signal |= SE_OPEN;
     } else {
       state_ = SSL_CONNECTING;
       if (int err = BeginSSL()) {
         Error("BeginSSL", err, 0, true);
         return;
       }
     }
   }
-  if ((events & (SE_READ|SE_WRITE))) {
+  if ((events & (SE_READ | SE_WRITE))) {
     LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent"
-                 << ((events & SE_READ) ? " SE_READ" : "")
-                 << ((events & SE_WRITE) ? " SE_WRITE" : "");
+                    << ((events & SE_READ) ? " SE_READ" : "")
+                    << ((events & SE_WRITE) ? " SE_WRITE" : "");
     if (state_ == SSL_NONE) {
-      events_to_signal |= events & (SE_READ|SE_WRITE);
+      events_to_signal |= events & (SE_READ | SE_WRITE);
     } else if (state_ == SSL_CONNECTING) {
       if (int err = ContinueSSL()) {
         Error("ContinueSSL", err, 0, true);
         return;
       }
     } else if (state_ == SSL_CONNECTED) {
       if (((events & SE_READ) && ssl_write_needs_read_) ||
           (events & SE_WRITE)) {
         LOG(LS_VERBOSE) << " -- onStreamWriteable";
         events_to_signal |= SE_WRITE;
@@ skipping 47 matching lines @@
 #ifdef OPENSSL_IS_BORINGSSL
     DTLSv1_set_initial_timeout_duration(ssl_, dtls_handshake_timeout_ms_);
 #else
     // Enable read-ahead for DTLS so whole packets are read from internal BIO
     // before parsing. This is done internally by BoringSSL for DTLS.
     SSL_set_read_ahead(ssl_, 1);
 #endif
   }
 
   SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE |
-               SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
+                         SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 
 #if !defined(OPENSSL_IS_BORINGSSL)
   // Specify an ECDH group for ECDHE ciphers, otherwise OpenSSL cannot
   // negotiate them when acting as the server. Use NIST's P-256 which is
   // commonly supported. BoringSSL doesn't need explicit configuration and has
   // a reasonable default set.
   EC_KEY* ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
   if (ecdh == nullptr)
     return -1;
   SSL_set_options(ssl_, SSL_OP_SINGLE_ECDH_USE);
@@ skipping 30 matching lines @@
         // TODO(deadbeef): Post this event asynchronously to unwind the stack.
         // The caller of ContinueSSL may be the same object listening for these
         // events and may not be prepared for reentrancy.
         // PostEvent(SE_OPEN | SE_READ | SE_WRITE, 0);
         StreamAdapterInterface::OnEvent(stream(), SE_OPEN | SE_READ | SE_WRITE,
                                         0);
       }
       break;
 
     case SSL_ERROR_WANT_READ: {
-        LOG(LS_VERBOSE) << " -- error want read";
-        struct timeval timeout;
-        if (DTLSv1_get_timeout(ssl_, &timeout)) {
-          int delay = timeout.tv_sec * 1000 + timeout.tv_usec/1000;
+      LOG(LS_VERBOSE) << " -- error want read";
+      struct timeval timeout;
+      if (DTLSv1_get_timeout(ssl_, &timeout)) {
+        int delay = timeout.tv_sec * 1000 + timeout.tv_usec / 1000;
 
-          Thread::Current()->PostDelayed(RTC_FROM_HERE, delay, this,
-                                         MSG_TIMEOUT, 0);
-        }
+        Thread::Current()->PostDelayed(RTC_FROM_HERE, delay, this, MSG_TIMEOUT,
+                                       0);
       }
-      break;
+    } break;
 
     case SSL_ERROR_WANT_WRITE:
       LOG(LS_VERBOSE) << " -- error want write";
       break;
 
     case SSL_ERROR_ZERO_RETURN:
     default:
       LOG(LS_VERBOSE) << " -- error " << code;
       SSLHandshakeError ssl_handshake_err = SSLHandshakeError::UNKNOWN;
       int err_code = ERR_peek_last_error();
@@ skipping 55 matching lines @@
     SSL_CTX_free(ssl_ctx_);
     ssl_ctx_ = nullptr;
   }
   identity_.reset();
   peer_certificate_.reset();
 
   // Clear the DTLS timer
   Thread::Current()->Clear(this, MSG_TIMEOUT);
 }
 
-
 void OpenSSLStreamAdapter::OnMessage(Message* msg) {
   // Process our own messages and then pass others to the superclass
   if (MSG_TIMEOUT == msg->message_id) {
     LOG(LS_INFO) << "DTLS timeout expired";
     DTLSv1_handle_timeout(ssl_);
     ContinueSSL();
   } else {
     StreamInterface::OnMessage(msg);
   }
 }
 
 SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
   SSL_CTX* ctx = nullptr;
 
 #ifdef OPENSSL_IS_BORINGSSL
-    ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
-        DTLS_method() : TLS_method());
-    // Version limiting for BoringSSL will be done below.
+  ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ? DTLS_method() : TLS_method());
+  // Version limiting for BoringSSL will be done below.
 #else
   const SSL_METHOD* method;
   switch (ssl_max_version_) {
     case SSL_PROTOCOL_TLS_10:
     case SSL_PROTOCOL_TLS_11:
       // OpenSSL doesn't support setting min/max versions, so we always use
       // (D)TLS 1.0 if a max. version below the max. available is requested.
       if (ssl_mode_ == SSL_MODE_DTLS) {
         if (role_ == SSL_CLIENT) {
           method = DTLSv1_client_method();
@@ skipping 43 matching lines @@
       }
       break;
   }
   ctx = SSL_CTX_new(method);
 #endif  // OPENSSL_IS_BORINGSSL
 
   if (ctx == nullptr)
     return nullptr;
 
 #ifdef OPENSSL_IS_BORINGSSL
-  SSL_CTX_set_min_proto_version(ctx, ssl_mode_ == SSL_MODE_DTLS ?
-      DTLS1_VERSION : TLS1_VERSION);
+  SSL_CTX_set_min_proto_version(
+      ctx, ssl_mode_ == SSL_MODE_DTLS ? DTLS1_VERSION : TLS1_VERSION);
   switch (ssl_max_version_) {
     case SSL_PROTOCOL_TLS_10:
-      SSL_CTX_set_max_proto_version(ctx, ssl_mode_ == SSL_MODE_DTLS ?
-          DTLS1_VERSION : TLS1_VERSION);
+      SSL_CTX_set_max_proto_version(
+          ctx, ssl_mode_ == SSL_MODE_DTLS ? DTLS1_VERSION : TLS1_VERSION);
       break;
     case SSL_PROTOCOL_TLS_11:
-      SSL_CTX_set_max_proto_version(ctx, ssl_mode_ == SSL_MODE_DTLS ?
-          DTLS1_VERSION : TLS1_1_VERSION);
+      SSL_CTX_set_max_proto_version(
+          ctx, ssl_mode_ == SSL_MODE_DTLS ? DTLS1_VERSION : TLS1_1_VERSION);
       break;
     case SSL_PROTOCOL_TLS_12:
     default:
-      SSL_CTX_set_max_proto_version(ctx, ssl_mode_ == SSL_MODE_DTLS ?
-          DTLS1_2_VERSION : TLS1_2_VERSION);
+      SSL_CTX_set_max_proto_version(
+          ctx, ssl_mode_ == SSL_MODE_DTLS ? DTLS1_2_VERSION : TLS1_2_VERSION);
       break;
   }
   if (g_use_time_callback_for_testing) {
     SSL_CTX_set_current_time_cb(ctx, &TimeCallbackForTesting);
   }
 #endif
 
   if (identity_ && !identity_->ConfigureIdentity(ctx)) {
     SSL_CTX_free(ctx);
     return nullptr;
@@ skipping 61 matching lines @@
 int OpenSSLStreamAdapter::SSLVerifyCallback(int ok, X509_STORE_CTX* store) {
   // Get our SSL structure from the store
   SSL* ssl = reinterpret_cast<SSL*>(
       X509_STORE_CTX_get_ex_data(store, SSL_get_ex_data_X509_STORE_CTX_idx()));
   X509* cert = X509_STORE_CTX_get_current_cert(store);
   int depth = X509_STORE_CTX_get_error_depth(store);
 
   // For now we ignore the parent certificates and verify the leaf against
   // the digest.
   //
-  // TODO(jiayl): Verify the chain is a proper chain and report the chain to
-  // |stream->peer_certificate_|.
-  if (depth > 0) {
-    LOG(LS_INFO) << "Ignored chained certificate at depth " << depth;
-    return 1;
-  }
 
   OpenSSLStreamAdapter* stream =
       reinterpret_cast<OpenSSLStreamAdapter*>(SSL_get_app_data(ssl));
+  if (depth == 0) {
+    // Record the peer's certificate.
+    stream->peer_certificate_.reset(new OpenSSLCertificate(cert));
+  } else {
+    STACK_OF(X509)* chain = X509_STORE_CTX_get_chain(store);
+    stream->peer_certificate_.reset(new OpenSSLCertificate(chain));
+  }
 
   // Record the peer's certificate.
   stream->peer_certificate_.reset(new OpenSSLCertificate(cert));
 
   // If the peer certificate digest isn't known yet, we'll wait to verify
   // until it's known, and for now just return a success status.
   if (stream->peer_certificate_digest_algorithm_.empty()) {
     LOG(LS_INFO) << "Waiting to verify certificate until digest is known.";
     return 1;
   }
@@ skipping 12 matching lines @@
 #define CDEF(X) \
   { static_cast<uint16_t>(TLS1_CK_##X & 0xffff), "TLS_" #X }
 
 struct cipher_list {
   uint16_t cipher;
   const char* cipher_str;
 };
 
 // TODO(torbjorng): Perhaps add more cipher suites to these lists.
 static const cipher_list OK_RSA_ciphers[] = {
-  CDEF(ECDHE_RSA_WITH_AES_128_CBC_SHA),
-  CDEF(ECDHE_RSA_WITH_AES_256_CBC_SHA),
-  CDEF(ECDHE_RSA_WITH_AES_128_GCM_SHA256),
+    CDEF(ECDHE_RSA_WITH_AES_128_CBC_SHA),
+    CDEF(ECDHE_RSA_WITH_AES_256_CBC_SHA),
+    CDEF(ECDHE_RSA_WITH_AES_128_GCM_SHA256),
 #ifdef TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA256
-  CDEF(ECDHE_RSA_WITH_AES_256_GCM_SHA256),
+    CDEF(ECDHE_RSA_WITH_AES_256_GCM_SHA256),
 #endif
 #ifdef TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
-  CDEF(ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256),
+    CDEF(ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256),
 #endif
 };
 
 static const cipher_list OK_ECDSA_ciphers[] = {
-  CDEF(ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
-  CDEF(ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
-  CDEF(ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
+    CDEF(ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
+    CDEF(ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
+    CDEF(ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
 #ifdef TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA256
-  CDEF(ECDHE_ECDSA_WITH_AES_256_GCM_SHA256),
+    CDEF(ECDHE_ECDSA_WITH_AES_256_GCM_SHA256),
 #endif
 #ifdef TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
-  CDEF(ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256),
+    CDEF(ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256),
 #endif
 };
 #undef CDEF
 
 bool OpenSSLStreamAdapter::IsAcceptableCipher(int cipher, KeyType key_type) {
   if (key_type == KT_RSA) {
     for (const cipher_list& c : OK_RSA_ciphers) {
       if (cipher == c.cipher)
         return true;
     }
@@ skipping 26 matching lines @@
   }
 
   return false;
 }
 
 void OpenSSLStreamAdapter::enable_time_callback_for_testing() {
   g_use_time_callback_for_testing = true;
 }
 
 }  // namespace rtc