1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
// 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.
#ifndef NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_
#define NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_
#include <string>
#include "net/quic/crypto/proof_verifier.h"
#include "net/quic/crypto/quic_crypto_client_config.h"
#include "net/quic/quic_config.h"
#include "net/quic/quic_crypto_stream.h"
#include "net/quic/quic_session_key.h"
namespace net {
class QuicSession;
namespace test {
class CryptoTestUtils;
} // namespace test
class NET_EXPORT_PRIVATE QuicCryptoClientStream : public QuicCryptoStream {
public:
class NET_EXPORT_PRIVATE Visitor {
public:
~Visitor() {}
// Called when the proof in |cached| is marked valid. If this is a secure
// QUIC session, then this will happen only after the proof verifier
// completes. If this is an insecure QUIC connection, this will happen
// as soon as a valid config is discovered (either from the cache or
// from the server).
virtual void OnProofValid(
const QuicCryptoClientConfig::CachedState& cached) = 0;
// Called when proof verification details become available, either because
// proof verification is complete, or when cached details are used. This
// will only be called for secure QUIC connections.
virtual void OnProofVerifyDetailsAvailable(
const ProofVerifyDetails& verify_details) = 0;
};
QuicCryptoClientStream(const QuicSessionKey& server_key,
QuicSession* session,
Visitor* visitor,
ProofVerifyContext* verify_context,
QuicCryptoClientConfig* crypto_config);
virtual ~QuicCryptoClientStream();
// CryptoFramerVisitorInterface implementation
virtual void OnHandshakeMessage(
const CryptoHandshakeMessage& message) OVERRIDE;
// Performs a crypto handshake with the server. Returns true if the crypto
// handshake is started successfully.
// TODO(agl): this should probably return void.
virtual bool CryptoConnect();
// num_sent_client_hellos returns the number of client hello messages that
// have been sent. If the handshake has completed then this is one greater
// than the number of round-trips needed for the handshake.
int num_sent_client_hellos() const;
Visitor* visitor() { return visitor_; }
private:
// ProofVerifierCallbackImpl is passed as the callback method to VerifyProof.
// The ProofVerifier calls this class with the result of proof verification
// when verification is performed asynchronously.
class ProofVerifierCallbackImpl : public ProofVerifierCallback {
public:
explicit ProofVerifierCallbackImpl(QuicCryptoClientStream* stream);
virtual ~ProofVerifierCallbackImpl();
// ProofVerifierCallback interface.
virtual void Run(bool ok,
const string& error_details,
scoped_ptr<ProofVerifyDetails>* details) OVERRIDE;
// Cancel causes any future callbacks to be ignored. It must be called on
// the same thread as the callback will be made on.
void Cancel();
private:
QuicCryptoClientStream* stream_;
};
friend class test::CryptoTestUtils;
friend class ProofVerifierCallbackImpl;
enum State {
STATE_IDLE,
STATE_INITIALIZE,
STATE_SEND_CHLO,
STATE_RECV_REJ,
STATE_VERIFY_PROOF,
STATE_VERIFY_PROOF_COMPLETE,
STATE_RECV_SHLO,
};
// DoHandshakeLoop performs a step of the handshake state machine. Note that
// |in| may be NULL if the call did not result from a received message.
void DoHandshakeLoop(const CryptoHandshakeMessage* in);
// Called to set the proof of |cached| valid. Also invokes the visitor's
// OnProofValid() method.
void SetCachedProofValid(QuicCryptoClientConfig::CachedState* cached);
Visitor* visitor_;
State next_state_;
// num_client_hellos_ contains the number of client hello messages that this
// connection has sent.
int num_client_hellos_;
QuicCryptoClientConfig* const crypto_config_;
// Client's connection nonce (4-byte timestamp + 28 random bytes)
std::string nonce_;
// Server's (hostname, port, is_https) tuple.
const QuicSessionKey server_key_;
// Generation counter from QuicCryptoClientConfig's CachedState.
uint64 generation_counter_;
// proof_verify_callback_ contains the callback object that we passed to an
// asynchronous proof verification. The ProofVerifier owns this object.
ProofVerifierCallbackImpl* proof_verify_callback_;
// These members are used to store the result of an asynchronous proof
// verification. These members must not be used after
// STATE_VERIFY_PROOF_COMPLETE.
bool verify_ok_;
string verify_error_details_;
scoped_ptr<ProofVerifyDetails> verify_details_;
scoped_ptr<ProofVerifyContext> verify_context_;
DISALLOW_COPY_AND_ASSIGN(QuicCryptoClientStream);
};
} // namespace net
#endif // NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_
|
