Home | History | Annotate | Download | only in socket 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef NET_SOCKET_SSL_CLIENT_SOCKET_OPENSSL_H_
      6 #define NET_SOCKET_SSL_CLIENT_SOCKET_OPENSSL_H_
      7 
      8 #include <string>
      9 
     10 #include "base/compiler_specific.h"
     11 #include "base/memory/scoped_ptr.h"
     12 #include "base/memory/weak_ptr.h"
     13 #include "net/base/completion_callback.h"
     14 #include "net/base/io_buffer.h"
     15 #include "net/cert/cert_verify_result.h"
     16 #include "net/cert/ct_verify_result.h"
     17 #include "net/socket/client_socket_handle.h"
     18 #include "net/socket/ssl_client_socket.h"
     19 #include "net/ssl/channel_id_service.h"
     20 #include "net/ssl/ssl_client_cert_type.h"
     21 #include "net/ssl/ssl_config_service.h"
     22 
     23 // Avoid including misc OpenSSL headers, i.e.:
     24 // <openssl/bio.h>
     25 typedef struct bio_st BIO;
     26 // <openssl/evp.h>
     27 typedef struct evp_pkey_st EVP_PKEY;
     28 // <openssl/ssl.h>
     29 typedef struct ssl_st SSL;
     30 // <openssl/x509.h>
     31 typedef struct x509_st X509;
     32 // <openssl/ossl_type.h>
     33 typedef struct x509_store_ctx_st X509_STORE_CTX;
     34 
     35 namespace net {
     36 
     37 class CertVerifier;
     38 class CTVerifier;
     39 class SingleRequestCertVerifier;
     40 class SSLCertRequestInfo;
     41 class SSLInfo;
     42 
     43 // An SSL client socket implemented with OpenSSL.
     44 class SSLClientSocketOpenSSL : public SSLClientSocket {
     45  public:
     46   // Takes ownership of the transport_socket, which may already be connected.
     47   // The given hostname will be compared with the name(s) in the server's
     48   // certificate during the SSL handshake.  ssl_config specifies the SSL
     49   // settings.
     50   SSLClientSocketOpenSSL(scoped_ptr<ClientSocketHandle> transport_socket,
     51                          const HostPortPair& host_and_port,
     52                          const SSLConfig& ssl_config,
     53                          const SSLClientSocketContext& context);
     54   virtual ~SSLClientSocketOpenSSL();
     55 
     56   const HostPortPair& host_and_port() const { return host_and_port_; }
     57   const std::string& ssl_session_cache_shard() const {
     58     return ssl_session_cache_shard_;
     59   }
     60 
     61   // SSLClientSocket implementation.
     62   virtual std::string GetSessionCacheKey() const OVERRIDE;
     63   virtual bool InSessionCache() const OVERRIDE;
     64   virtual void SetHandshakeCompletionCallback(
     65       const base::Closure& callback) OVERRIDE;
     66   virtual void GetSSLCertRequestInfo(
     67       SSLCertRequestInfo* cert_request_info) OVERRIDE;
     68   virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
     69   virtual ChannelIDService* GetChannelIDService() const OVERRIDE;
     70 
     71   // SSLSocket implementation.
     72   virtual int ExportKeyingMaterial(const base::StringPiece& label,
     73                                    bool has_context,
     74                                    const base::StringPiece& context,
     75                                    unsigned char* out,
     76                                    unsigned int outlen) OVERRIDE;
     77   virtual int GetTLSUniqueChannelBinding(std::string* out) OVERRIDE;
     78 
     79   // StreamSocket implementation.
     80   virtual int Connect(const CompletionCallback& callback) OVERRIDE;
     81   virtual void Disconnect() OVERRIDE;
     82   virtual bool IsConnected() const OVERRIDE;
     83   virtual bool IsConnectedAndIdle() const OVERRIDE;
     84   virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
     85   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
     86   virtual const BoundNetLog& NetLog() const OVERRIDE;
     87   virtual void SetSubresourceSpeculation() OVERRIDE;
     88   virtual void SetOmniboxSpeculation() OVERRIDE;
     89   virtual bool WasEverUsed() const OVERRIDE;
     90   virtual bool UsingTCPFastOpen() const OVERRIDE;
     91   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
     92 
     93   // Socket implementation.
     94   virtual int Read(IOBuffer* buf, int buf_len,
     95                    const CompletionCallback& callback) OVERRIDE;
     96   virtual int Write(IOBuffer* buf, int buf_len,
     97                     const CompletionCallback& callback) OVERRIDE;
     98   virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
     99   virtual int SetSendBufferSize(int32 size) OVERRIDE;
    100 
    101  protected:
    102   // SSLClientSocket implementation.
    103   virtual scoped_refptr<X509Certificate> GetUnverifiedServerCertificateChain()
    104       const OVERRIDE;
    105 
    106  private:
    107   class PeerCertificateChain;
    108   class SSLContext;
    109   friend class SSLClientSocket;
    110   friend class SSLContext;
    111 
    112   int Init();
    113   void DoReadCallback(int result);
    114   void DoWriteCallback(int result);
    115 
    116   void OnHandshakeCompletion();
    117 
    118   bool DoTransportIO();
    119   int DoHandshake();
    120   int DoChannelIDLookup();
    121   int DoChannelIDLookupComplete(int result);
    122   int DoVerifyCert(int result);
    123   int DoVerifyCertComplete(int result);
    124   void DoConnectCallback(int result);
    125   void UpdateServerCert();
    126   void VerifyCT();
    127 
    128   void OnHandshakeIOComplete(int result);
    129   void OnSendComplete(int result);
    130   void OnRecvComplete(int result);
    131 
    132   int DoHandshakeLoop(int last_io_result);
    133   int DoReadLoop();
    134   int DoWriteLoop();
    135   int DoPayloadRead();
    136   int DoPayloadWrite();
    137 
    138   int BufferSend();
    139   int BufferRecv();
    140   void BufferSendComplete(int result);
    141   void BufferRecvComplete(int result);
    142   void TransportWriteComplete(int result);
    143   int TransportReadComplete(int result);
    144 
    145   // Callback from the SSL layer that indicates the remote server is requesting
    146   // a certificate for this client.
    147   int ClientCertRequestCallback(SSL* ssl);
    148 
    149   // CertVerifyCallback is called to verify the server's certificates. We do
    150   // verification after the handshake so this function only enforces that the
    151   // certificates don't change during renegotiation.
    152   int CertVerifyCallback(X509_STORE_CTX *store_ctx);
    153 
    154   // Callback from the SSL layer to check which NPN protocol we are supporting
    155   int SelectNextProtoCallback(unsigned char** out, unsigned char* outlen,
    156                               const unsigned char* in, unsigned int inlen);
    157 
    158   // Called during an operation on |transport_bio_|'s peer. Checks saved
    159   // transport error state and, if appropriate, returns an error through
    160   // OpenSSL's error system.
    161   long MaybeReplayTransportError(BIO *bio,
    162                                  int cmd,
    163                                  const char *argp, int argi, long argl,
    164                                  long retvalue);
    165 
    166   // Callback from the SSL layer when an operation is performed on
    167   // |transport_bio_|'s peer.
    168   static long BIOCallback(BIO *bio,
    169                           int cmd,
    170                           const char *argp, int argi, long argl,
    171                           long retvalue);
    172 
    173   // Callback that is used to obtain information about the state of the SSL
    174   // handshake.
    175   static void InfoCallback(const SSL* ssl, int type, int val);
    176 
    177   void CheckIfHandshakeFinished();
    178 
    179   // Adds the SignedCertificateTimestamps from ct_verify_result_ to |ssl_info|.
    180   // SCTs are held in three separate vectors in ct_verify_result, each
    181   // vetor representing a particular verification state, this method associates
    182   // each of the SCTs with the corresponding SCTVerifyStatus as it adds it to
    183   // the |ssl_info|.signed_certificate_timestamps list.
    184   void AddSCTInfoToSSLInfo(SSLInfo* ssl_info) const;
    185 
    186   bool transport_send_busy_;
    187   bool transport_recv_busy_;
    188 
    189   scoped_refptr<DrainableIOBuffer> send_buffer_;
    190   scoped_refptr<IOBuffer> recv_buffer_;
    191 
    192   CompletionCallback user_connect_callback_;
    193   CompletionCallback user_read_callback_;
    194   CompletionCallback user_write_callback_;
    195 
    196   // Used by Read function.
    197   scoped_refptr<IOBuffer> user_read_buf_;
    198   int user_read_buf_len_;
    199 
    200   // Used by Write function.
    201   scoped_refptr<IOBuffer> user_write_buf_;
    202   int user_write_buf_len_;
    203 
    204   // Used by DoPayloadRead() when attempting to fill the caller's buffer with
    205   // as much data as possible without blocking.
    206   // If DoPayloadRead() encounters an error after having read some data, stores
    207   // the result to return on the *next* call to DoPayloadRead().  A value > 0
    208   // indicates there is no pending result, otherwise 0 indicates EOF and < 0
    209   // indicates an error.
    210   int pending_read_error_;
    211 
    212   // Used by TransportReadComplete() to signify an error reading from the
    213   // transport socket. A value of OK indicates the socket is still
    214   // readable. EOFs are mapped to ERR_CONNECTION_CLOSED.
    215   int transport_read_error_;
    216 
    217   // Used by TransportWriteComplete() and TransportReadComplete() to signify an
    218   // error writing to the transport socket. A value of OK indicates no error.
    219   int transport_write_error_;
    220 
    221   // Set when Connect finishes.
    222   scoped_ptr<PeerCertificateChain> server_cert_chain_;
    223   scoped_refptr<X509Certificate> server_cert_;
    224   CertVerifyResult server_cert_verify_result_;
    225   bool completed_connect_;
    226 
    227   // Set when Read() or Write() successfully reads or writes data to or from the
    228   // network.
    229   bool was_ever_used_;
    230 
    231   // Stores client authentication information between ClientAuthHandler and
    232   // GetSSLCertRequestInfo calls.
    233   bool client_auth_cert_needed_;
    234   // List of DER-encoded X.509 DistinguishedName of certificate authorities
    235   // allowed by the server.
    236   std::vector<std::string> cert_authorities_;
    237   // List of SSLClientCertType values for client certificates allowed by the
    238   // server.
    239   std::vector<SSLClientCertType> cert_key_types_;
    240 
    241   CertVerifier* const cert_verifier_;
    242   scoped_ptr<SingleRequestCertVerifier> verifier_;
    243   base::TimeTicks start_cert_verification_time_;
    244 
    245   // Certificate Transparency: Verifier and result holder.
    246   ct::CTVerifyResult ct_verify_result_;
    247   CTVerifier* cert_transparency_verifier_;
    248 
    249   // The service for retrieving Channel ID keys.  May be NULL.
    250   ChannelIDService* channel_id_service_;
    251 
    252   // Callback that is invoked when the connection finishes.
    253   //
    254   // Note: this callback will be run in Disconnect(). It will not alter
    255   // any member variables of the SSLClientSocketOpenSSL.
    256   base::Closure handshake_completion_callback_;
    257 
    258   // OpenSSL stuff
    259   SSL* ssl_;
    260   BIO* transport_bio_;
    261 
    262   scoped_ptr<ClientSocketHandle> transport_;
    263   const HostPortPair host_and_port_;
    264   SSLConfig ssl_config_;
    265   // ssl_session_cache_shard_ is an opaque string that partitions the SSL
    266   // session cache. i.e. sessions created with one value will not attempt to
    267   // resume on the socket with a different value.
    268   const std::string ssl_session_cache_shard_;
    269 
    270   // Used for session cache diagnostics.
    271   bool trying_cached_session_;
    272 
    273   enum State {
    274     STATE_NONE,
    275     STATE_HANDSHAKE,
    276     STATE_CHANNEL_ID_LOOKUP,
    277     STATE_CHANNEL_ID_LOOKUP_COMPLETE,
    278     STATE_VERIFY_CERT,
    279     STATE_VERIFY_CERT_COMPLETE,
    280   };
    281   State next_handshake_state_;
    282   NextProtoStatus npn_status_;
    283   std::string npn_proto_;
    284   // Written by the |channel_id_service_|.
    285   std::string channel_id_private_key_;
    286   std::string channel_id_cert_;
    287   // True if channel ID extension was negotiated.
    288   bool channel_id_xtn_negotiated_;
    289   // True if InfoCallback has been run with result = SSL_CB_HANDSHAKE_DONE.
    290   bool handshake_succeeded_;
    291   // True if MarkSSLSessionAsGood has been called for this socket's
    292   // SSL session.
    293   bool marked_session_as_good_;
    294   // The request handle for |channel_id_service_|.
    295   ChannelIDService::RequestHandle channel_id_request_handle_;
    296 
    297   TransportSecurityState* transport_security_state_;
    298 
    299   // pinning_failure_log contains a message produced by
    300   // TransportSecurityState::CheckPublicKeyPins in the event of a
    301   // pinning failure. It is a (somewhat) human-readable string.
    302   std::string pinning_failure_log_;
    303 
    304   BoundNetLog net_log_;
    305   base::WeakPtrFactory<SSLClientSocketOpenSSL> weak_factory_;
    306 };
    307 
    308 }  // namespace net
    309 
    310 #endif  // NET_SOCKET_SSL_CLIENT_SOCKET_OPENSSL_H_
    311