Add functionality to pppapi TCPSocket to support secure sockets in flash

content/browser/renderer_host/pepper_tcp_socket.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/pepper_tcp_socket.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 86 matching lines @@
       !NetAddressPrivateImpl::NetAddressToAddressList(net_addr,
                                                       &address_list_)) {
     SendConnectACKError();
     return;
   }
 
   connection_state_ = CONNECT_IN_PROGRESS;
   StartConnect(address_list_);
 }
 
-void PepperTCPSocket::SSLHandshake(const std::string& server_name,
-                                   uint16_t server_port) {
+void PepperTCPSocket::SSLHandshake(
+    const std::string& server_name,
+    uint16_t server_port,
+    const std::vector<std::vector<char> >& trusted_certs,
+    const std::vector<std::vector<char> >& untrusted_certs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Allow to do SSL handshake only if currently the socket has been connected
   // and there isn't pending read or write.
   // IsConnected() includes the state that SSL handshake has been finished and
   // therefore isn't suitable here.
   if (connection_state_ != CONNECTED || read_buffer_.get() ||
       write_buffer_.get()) {
     SendSSLHandshakeACK(false);
     return;
   }
 
   connection_state_ = SSL_HANDSHAKE_IN_PROGRESS;
+  // TODO(raymes,rsleevi): Use trusted/untrusted certificates when connecting.
+
   net::ClientSocketHandle* handle = new net::ClientSocketHandle();
   handle->set_socket(socket_.release());
   net::ClientSocketFactory* factory =
       net::ClientSocketFactory::GetDefaultFactory();
   net::HostPortPair host_port_pair(server_name, server_port);
   net::SSLClientSocketContext ssl_context;
   ssl_context.cert_verifier = manager_->GetCertVerifier();
   socket_.reset(factory->CreateSSLClientSocket(
       handle, host_port_pair, manager_->ssl_config(), NULL, ssl_context));
   if (!socket_.get()) {
@@ skipping 136 matching lines @@
   manager_->Send(new PpapiMsg_PPBTCPSocket_ReadACK(
     routing_id_, plugin_dispatcher_id_, socket_id_, false, std::string()));
 }
 
 void PepperTCPSocket::SendWriteACKError() {
   manager_->Send(new PpapiMsg_PPBTCPSocket_WriteACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
 }
 
 void PepperTCPSocket::SendSSLHandshakeACK(bool succeeded) {
+  ppapi::PPB_X509Certificate_Fields certificate_fields;
+  if (succeeded) {
+    CHECK(socket_.get());

[yzshen1, 2012/04/06 19:24:33]

You don't need this CHECK, it will die below if it is NULL, right? (And also
line 291).

[raymes, 2012/04/06 23:22:47]

Done.

+    // Our socket is guaranteed to be an SSL socket if we get here.
+    net::SSLClientSocket* ssl_socket =
+        static_cast<net::SSLClientSocket*>(socket_.get());
+    net::SSLInfo ssl_info;
+    ssl_socket->GetSSLInfo(&ssl_info);
+    CHECK(ssl_info.cert.get());

[Ryan Sleevi, 2012/04/06 00:37:49]

Note that this can fail for a variety of reasons. The most common is that a
certificate has a validity date range that exceeds the systems' clock
representation - eg: 2038 for 32-bit time_t (OpenSSL) or earlier than 1601
(Windows).

I have a bug open to go back through and 'gracefully' handle these. So I'd
encourage you not to CHECK() here and think about how you might gracefully
handle this.

[raymes, 2012/04/06 23:22:47]

Done.

+    bool success = GetCertificateFields(*ssl_info.cert,
+                                        &certificate_fields);
+    CHECK(success);

[yzshen1, 2012/04/06 19:24:33]

If it failed, do we have to crash the whole browser?

[raymes, 2012/04/06 23:22:47]

Probably not. If we can't correctly parse the cert, it's probably best to just
return an empty cert for now. Done.

+  }
   manager_->Send(new PpapiMsg_PPBTCPSocket_SSLHandshakeACK(
-      routing_id_, plugin_dispatcher_id_, socket_id_, succeeded));
+      routing_id_,
+      plugin_dispatcher_id_,
+      socket_id_,
+      succeeded,
+      certificate_fields));
 }
 
 void PepperTCPSocket::OnResolveCompleted(int result) {
   DCHECK(connection_state_ == CONNECT_IN_PROGRESS);
 
   if (result != net::OK) {
     SendConnectACKError();
     connection_state_ = BEFORE_CONNECT;
     return;
   }
@@ skipping 65 matching lines @@
         routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
   } else {
     SendWriteACKError();
   }
   write_buffer_ = NULL;
 }
 
 bool PepperTCPSocket::IsConnected() const {
   return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
 }