Home | History | Annotate | Download | only in quic 
      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_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_
      6 #define NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_
      7 
      8 #include <string>
      9 
     10 #include "net/quic/crypto/channel_id.h"
     11 #include "net/quic/crypto/proof_verifier.h"
     12 #include "net/quic/crypto/quic_crypto_client_config.h"
     13 #include "net/quic/quic_config.h"
     14 #include "net/quic/quic_crypto_stream.h"
     15 #include "net/quic/quic_server_id.h"
     16 
     17 namespace net {
     18 
     19 class QuicClientSessionBase;
     20 
     21 namespace test {
     22 class CryptoTestUtils;
     23 class QuicClientSessionPeer;
     24 }  // namespace test
     25 
     26 class NET_EXPORT_PRIVATE QuicCryptoClientStream : public QuicCryptoStream {
     27  public:
     28   QuicCryptoClientStream(const QuicServerId& server_id,
     29                          QuicClientSessionBase* session,
     30                          ProofVerifyContext* verify_context,
     31                          QuicCryptoClientConfig* crypto_config);
     32   virtual ~QuicCryptoClientStream();
     33 
     34   // CryptoFramerVisitorInterface implementation
     35   virtual void OnHandshakeMessage(
     36       const CryptoHandshakeMessage& message) OVERRIDE;
     37 
     38   // Performs a crypto handshake with the server. Returns true if the crypto
     39   // handshake is started successfully.
     40   // TODO(agl): this should probably return void.
     41   virtual bool CryptoConnect();
     42 
     43   // num_sent_client_hellos returns the number of client hello messages that
     44   // have been sent. If the handshake has completed then this is one greater
     45   // than the number of round-trips needed for the handshake.
     46   int num_sent_client_hellos() const;
     47 
     48   // Returns true if a channel ID was sent on this connection.
     49   bool WasChannelIDSent() const;
     50 
     51   // Returns true if our ChannelIDSourceCallback was run, which implies the
     52   // ChannelIDSource operated asynchronously. Intended for testing.
     53   bool WasChannelIDSourceCallbackRun() const;
     54 
     55  private:
     56   // ChannelIDSourceCallbackImpl is passed as the callback method to
     57   // GetChannelIDKey. The ChannelIDSource calls this class with the result of
     58   // channel ID lookup when lookup is performed asynchronously.
     59   class ChannelIDSourceCallbackImpl : public ChannelIDSourceCallback {
     60    public:
     61     explicit ChannelIDSourceCallbackImpl(QuicCryptoClientStream* stream);
     62     virtual ~ChannelIDSourceCallbackImpl();
     63 
     64     // ChannelIDSourceCallback interface.
     65     virtual void Run(scoped_ptr<ChannelIDKey>* channel_id_key) OVERRIDE;
     66 
     67     // Cancel causes any future callbacks to be ignored. It must be called on
     68     // the same thread as the callback will be made on.
     69     void Cancel();
     70 
     71    private:
     72     QuicCryptoClientStream* stream_;
     73   };
     74 
     75   // ProofVerifierCallbackImpl is passed as the callback method to VerifyProof.
     76   // The ProofVerifier calls this class with the result of proof verification
     77   // when verification is performed asynchronously.
     78   class ProofVerifierCallbackImpl : public ProofVerifierCallback {
     79    public:
     80     explicit ProofVerifierCallbackImpl(QuicCryptoClientStream* stream);
     81     virtual ~ProofVerifierCallbackImpl();
     82 
     83     // ProofVerifierCallback interface.
     84     virtual void Run(bool ok,
     85                      const string& error_details,
     86                      scoped_ptr<ProofVerifyDetails>* details) OVERRIDE;
     87 
     88     // Cancel causes any future callbacks to be ignored. It must be called on
     89     // the same thread as the callback will be made on.
     90     void Cancel();
     91 
     92    private:
     93     QuicCryptoClientStream* stream_;
     94   };
     95 
     96   friend class test::CryptoTestUtils;
     97   friend class test::QuicClientSessionPeer;
     98 
     99   enum State {
    100     STATE_IDLE,
    101     STATE_INITIALIZE,
    102     STATE_SEND_CHLO,
    103     STATE_RECV_REJ,
    104     STATE_VERIFY_PROOF,
    105     STATE_VERIFY_PROOF_COMPLETE,
    106     STATE_GET_CHANNEL_ID,
    107     STATE_GET_CHANNEL_ID_COMPLETE,
    108     STATE_RECV_SHLO,
    109     STATE_INITIALIZE_SCUP,
    110     STATE_VERIFY_PROOF_DONE,
    111   };
    112 
    113   // Handles new server config and optional source-address token provided by the
    114   // server during a connection.
    115   void HandleServerConfigUpdateMessage(
    116       const CryptoHandshakeMessage& server_config_update);
    117 
    118   // DoHandshakeLoop performs a step of the handshake state machine. Note that
    119   // |in| may be NULL if the call did not result from a received message.
    120   void DoHandshakeLoop(const CryptoHandshakeMessage* in);
    121 
    122   // Start the proof verification if |server_id_| is https and |cached| has
    123   // signature.
    124   void DoInitializeServerConfigUpdate(
    125       QuicCryptoClientConfig::CachedState* cached);
    126 
    127   // Starts the proof verification. Returns the QuicAsyncStatus returned by the
    128   // ProofVerifier's VerifyProof.
    129   QuicAsyncStatus DoVerifyProof(QuicCryptoClientConfig::CachedState* cached);
    130 
    131   // If proof is valid then it sets the proof as valid (which persists the
    132   // server config) and returns QUIC_NO_ERROR. If not, it closes the connection
    133   // and returns QUIC_PROOF_INVALID.
    134   QuicErrorCode DoVerifyProofComplete(
    135       QuicCryptoClientConfig::CachedState* cached);
    136 
    137   // Called to set the proof of |cached| valid.  Also invokes the session's
    138   // OnProofValid() method.
    139   void SetCachedProofValid(QuicCryptoClientConfig::CachedState* cached);
    140 
    141   // Returns true if the server crypto config in |cached| requires a ChannelID
    142   // and the client config settings also allow sending a ChannelID.
    143   bool RequiresChannelID(QuicCryptoClientConfig::CachedState* cached);
    144 
    145   QuicClientSessionBase* client_session();
    146 
    147   State next_state_;
    148   // num_client_hellos_ contains the number of client hello messages that this
    149   // connection has sent.
    150   int num_client_hellos_;
    151 
    152   QuicCryptoClientConfig* const crypto_config_;
    153 
    154   // Client's connection nonce (4-byte timestamp + 28 random bytes)
    155   std::string nonce_;
    156   // Server's (hostname, port, is_https, privacy_mode) tuple.
    157   const QuicServerId server_id_;
    158 
    159   // Generation counter from QuicCryptoClientConfig's CachedState.
    160   uint64 generation_counter_;
    161 
    162   // True if a channel ID was sent.
    163   bool channel_id_sent_;
    164 
    165   // True if channel_id_source_callback_ was run.
    166   bool channel_id_source_callback_run_;
    167 
    168   // channel_id_source_callback_ contains the callback object that we passed
    169   // to an asynchronous channel ID lookup. The ChannelIDSource owns this
    170   // object.
    171   ChannelIDSourceCallbackImpl* channel_id_source_callback_;
    172 
    173   // These members are used to store the result of an asynchronous channel ID
    174   // lookup. These members must not be used after
    175   // STATE_GET_CHANNEL_ID_COMPLETE.
    176   scoped_ptr<ChannelIDKey> channel_id_key_;
    177 
    178   // verify_context_ contains the context object that we pass to asynchronous
    179   // proof verifications.
    180   scoped_ptr<ProofVerifyContext> verify_context_;
    181 
    182   // proof_verify_callback_ contains the callback object that we passed to an
    183   // asynchronous proof verification. The ProofVerifier owns this object.
    184   ProofVerifierCallbackImpl* proof_verify_callback_;
    185 
    186   // These members are used to store the result of an asynchronous proof
    187   // verification. These members must not be used after
    188   // STATE_VERIFY_PROOF_COMPLETE.
    189   bool verify_ok_;
    190   string verify_error_details_;
    191   scoped_ptr<ProofVerifyDetails> verify_details_;
    192 
    193   DISALLOW_COPY_AND_ASSIGN(QuicCryptoClientStream);
    194 };
    195 
    196 }  // namespace net
    197 
    198 #endif  // NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_
    199