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 85 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;
+  std::vector<scoped_refptr<net::X509Certificate> > parsed_trusted_certs;
+  std::vector<scoped_refptr<net::X509Certificate> > parsed_untrusted_certs;
+  bool success = ParseCertificates(trusted_certs, &parsed_trusted_certs) &&
+      ParseCertificates(untrusted_certs, &parsed_untrusted_certs);
+  if (!success) {
+    LOG(WARNING) << "Failed to parse socket-specific certificates.";
+    OnSSLHandshakeCompleted(net::ERR_CERT_CONTAINS_ERRORS);
+    return;
+  }
+  // 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 97 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());
+    // 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);
+    bool success = GetCertificateFields(*ssl_info.cert,
+                                        &certificate_fields);
+    CHECK(success);
+  }
   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;
 }
+
+bool PepperTCPSocket::ParseCertificates(
+    const std::vector<std::vector<char> >& certs,
+    std::vector<scoped_refptr<net::X509Certificate> >* result) {
+  for (size_t i = 0; i < certs.size(); ++i) {
+    if (certs[i].size() == 0) {
+      return false;
+    }
+    scoped_refptr<net::X509Certificate> cert =
+          net::X509Certificate::CreateFromBytes(&certs[i][0],
+                                                certs[i].size());
+    result->push_back(cert);
+  }
+  return true;
+}