src/net/quic/quic_crypto_client_stream.h

   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_