Add X509Certificate::Verify stubs for Mac and Linux....

net/base/ssl_client_socket_win.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/ssl_client_socket_win.h"
 
 #include <schnlsp.h>
 
 #include "base/lock.h"
 #include "base/singleton.h"
@@ skipping 197 matching lines @@
                                        const SSLConfig& ssl_config)
 #pragma warning(suppress: 4355)
     : io_callback_(this, &SSLClientSocketWin::OnIOComplete),
       transport_(transport_socket),
       hostname_(hostname),
       ssl_config_(ssl_config),
       user_callback_(NULL),
       user_buf_(NULL),
       user_buf_len_(0),
       next_state_(STATE_NONE),
-      server_cert_(NULL),
       creds_(NULL),
       payload_send_buffer_len_(0),
       bytes_sent_(0),
       decrypted_ptr_(NULL),
       bytes_decrypted_(0),
       received_ptr_(NULL),
       bytes_received_(0),
       completed_handshake_(false),
       complete_handshake_on_write_complete_(false),
       ignore_ok_result_(false),
       no_client_cert_(false) {
   memset(&stream_sizes_, 0, sizeof(stream_sizes_));
   memset(&send_buffer_, 0, sizeof(send_buffer_));
   memset(&ctxt_, 0, sizeof(ctxt_));
 }
 
 SSLClientSocketWin::~SSLClientSocketWin() {
   Disconnect();
 }
 
 void SSLClientSocketWin::GetSSLInfo(SSLInfo* ssl_info) {
-  SECURITY_STATUS status = SEC_E_OK;
-  if (server_cert_ == NULL) {
-    status = QueryContextAttributes(&ctxt_,
-                                    SECPKG_ATTR_REMOTE_CERT_CONTEXT,
-                                    &server_cert_);
-  }
-  if (status == SEC_E_OK) {
-    DCHECK(server_cert_);
-    PCCERT_CONTEXT dup_cert = CertDuplicateCertificateContext(server_cert_);
-    ssl_info->cert = X509Certificate::CreateFromHandle(
-        dup_cert, X509Certificate::SOURCE_FROM_NETWORK);
-  }
+  if (!server_cert_)
+    return;
+
+  ssl_info->cert = server_cert_;
+  ssl_info->cert_status = server_cert_verify_result_.cert_status;
   SecPkgContext_ConnectionInfo connection_info;
-  status = QueryContextAttributes(&ctxt_,
-                                  SECPKG_ATTR_CONNECTION_INFO,
-                                  &connection_info);
+  SECURITY_STATUS status = QueryContextAttributes(
+      &ctxt_, SECPKG_ATTR_CONNECTION_INFO, &connection_info);
   if (status == SEC_E_OK) {
     // TODO(wtc): compute the overall security strength, taking into account
     // dwExchStrength and dwHashStrength.  dwExchStrength needs to be
     // normalized.
     ssl_info->security_bits = connection_info.dwCipherStrength;
   }
-  ssl_info->cert_status = server_cert_verify_result_.cert_status;
 }
 
 int SSLClientSocketWin::Connect(CompletionCallback* callback) {
   DCHECK(transport_.get());
   DCHECK(next_state_ == STATE_NONE);
   DCHECK(!user_callback_);
 
   int ssl_version_mask = 0;
   if (ssl_config_.ssl2_enabled)
     ssl_version_mask |= SSL2;
@@ skipping 26 matching lines @@
   transport_->Disconnect();
 
   if (send_buffer_.pvBuffer) {
     FreeContextBuffer(send_buffer_.pvBuffer);
     memset(&send_buffer_, 0, sizeof(send_buffer_));
   }
   if (ctxt_.dwLower || ctxt_.dwUpper) {
     DeleteSecurityContext(&ctxt_);
     memset(&ctxt_, 0, sizeof(ctxt_));
   }
-  if (server_cert_) {
-    CertFreeCertificateContext(server_cert_);
+  if (server_cert_)
     server_cert_ = NULL;
-  }
 
   // TODO(wtc): reset more members?
   bytes_decrypted_ = 0;
   bytes_received_ = 0;
 }
 
 bool SSLClientSocketWin::IsConnected() const {
   // Ideally, we should also check if we have received the close_notify alert
   // message from the server, and return false in that case.  We're not doing
   // that, so this function may return a false positive.  Since the upper
@@ skipping 367 matching lines @@
   }
 
   return OK;
 }
 
 // Set server_cert_status_ and return OK or a network error.
 int SSLClientSocketWin::DoVerifyCert() {
   next_state_ = STATE_VERIFY_CERT_COMPLETE;
 
   DCHECK(server_cert_);
-
-  PCCERT_CONTEXT dup_cert = CertDuplicateCertificateContext(server_cert_);
-  scoped_refptr<X509Certificate> cert =
-      X509Certificate::CreateFromHandle(dup_cert,
-                                        X509Certificate::SOURCE_FROM_NETWORK);
-  return verifier_.Verify(cert, hostname_, ssl_config_.rev_checking_enabled,
+  return verifier_.Verify(server_cert_, hostname_,
+                          ssl_config_.rev_checking_enabled,
                           &server_cert_verify_result_, &io_callback_);
 }
 
 int SSLClientSocketWin::DoVerifyCertComplete(int result) {
   LogConnectionTypeMetrics();
   return result;
 }
 
 int SSLClientSocketWin::DoPayloadRead() {
   next_state_ = STATE_PAYLOAD_READ_COMPLETE;
@@ skipping 201 matching lines @@
 }
 
 int SSLClientSocketWin::DidCompleteHandshake() {
   SECURITY_STATUS status = QueryContextAttributes(
       &ctxt_, SECPKG_ATTR_STREAM_SIZES, &stream_sizes_);
   if (status != SEC_E_OK) {
     DLOG(ERROR) << "QueryContextAttributes failed: " << status;
     return MapSecurityError(status);
   }
   DCHECK(!server_cert_);
+  PCCERT_CONTEXT server_cert_handle = NULL;
   status = QueryContextAttributes(
-      &ctxt_, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &server_cert_);
+      &ctxt_, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &server_cert_handle);
   if (status != SEC_E_OK) {
     DLOG(ERROR) << "QueryContextAttributes failed: " << status;
     return MapSecurityError(status);
   }
+  server_cert_ = X509Certificate::CreateFromHandle(
+      server_cert_handle, X509Certificate::SOURCE_FROM_NETWORK);
 
   completed_handshake_ = true;
   next_state_ = STATE_VERIFY_CERT;
   return OK;
 }
 
 void SSLClientSocketWin::LogConnectionTypeMetrics() const {
   UpdateConnectionTypeHistograms(CONNECTION_SSL);
   if (server_cert_verify_result_.has_md5)
     UpdateConnectionTypeHistograms(CONNECTION_SSL_MD5);
   if (server_cert_verify_result_.has_md2)
     UpdateConnectionTypeHistograms(CONNECTION_SSL_MD2);
   if (server_cert_verify_result_.has_md4)
     UpdateConnectionTypeHistograms(CONNECTION_SSL_MD4);
   if (server_cert_verify_result_.has_md5_ca)
     UpdateConnectionTypeHistograms(CONNECTION_SSL_MD5_CA);
   if (server_cert_verify_result_.has_md2_ca)
     UpdateConnectionTypeHistograms(CONNECTION_SSL_MD2_CA);
 }
 
 }  // namespace net