blob: 57ebfb048478efc4b2bf2ab63ae30003c2a2f767 (
plain)
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
|
// Copyright (c) 2013 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_CRYPTO_CRYPTO_SERVER_CONFIG_PROTOBUF_H_
#define NET_QUIC_CRYPTO_CRYPTO_SERVER_CONFIG_PROTOBUF_H_
#include <string>
#include <vector>
#include "base/logging.h"
#include "base/stl_util.h"
#include "base/strings/string_piece.h"
#include "net/base/net_export.h"
#include "net/quic/crypto/crypto_protocol.h"
namespace net {
// QuicServerConfigProtobuf contains QUIC server config block and the private
// keys needed to prove ownership.
// TODO(rch): sync with server more rationally.
class NET_EXPORT_PRIVATE QuicServerConfigProtobuf {
public:
// PrivateKey contains a QUIC tag of a key exchange algorithm and a
// serialised private key for that algorithm. The format of the serialised
// private key is specific to the algorithm in question.
class NET_EXPORT_PRIVATE PrivateKey {
public:
QuicTag tag() const {
return tag_;
}
void set_tag(QuicTag tag) {
tag_ = tag;
}
std::string private_key() const {
return private_key_;
}
void set_private_key(std::string key) {
private_key_ = key;
}
private:
QuicTag tag_;
std::string private_key_;
};
QuicServerConfigProtobuf();
~QuicServerConfigProtobuf();
size_t key_size() const {
return keys_.size();
}
const PrivateKey& key(size_t i) const {
DCHECK_GT(keys_.size(), i);
return *keys_[i];
}
std::string config() const {
return config_;
}
void set_config(base::StringPiece config) {
config.CopyToString(&config_);
}
QuicServerConfigProtobuf::PrivateKey* add_key() {
keys_.push_back(new PrivateKey);
return keys_.back();
}
void clear_key() {
STLDeleteElements(&keys_);
}
bool has_primary_time() const {
return primary_time_ > 0;
}
int64 primary_time() const {
return primary_time_;
}
void set_primary_time(int64 primary_time) {
primary_time_ = primary_time;
}
bool has_priority() const {
return priority_ > 0;
}
uint64 priority() const {
return priority_;
}
void set_priority(int64 priority) {
priority_ = priority;
}
bool has_source_address_token_secret_override() const {
return !source_address_token_secret_override_.empty();
}
std::string source_address_token_secret_override() const {
return source_address_token_secret_override_;
}
void set_source_address_token_secret_override(
base::StringPiece source_address_token_secret_override) {
source_address_token_secret_override.CopyToString(
&source_address_token_secret_override_);
}
private:
std::vector<PrivateKey*> keys_;
// config_ is a serialised config in QUIC wire format.
std::string config_;
// primary_time_ contains a UNIX epoch seconds value that indicates when this
// config should become primary.
int64 primary_time_;
// Relative priority of this config vs other configs with the same
// primary time. For use as a secondary sort key when selecting the
// primary config.
uint64 priority_;
// Optional override to the secret used to box/unbox source address
// tokens when talking to clients that select this server config.
// It can be of any length as it is fed into a KDF before use.
std::string source_address_token_secret_override_;
DISALLOW_COPY_AND_ASSIGN(QuicServerConfigProtobuf);
};
} // namespace net
#endif // NET_QUIC_CRYPTO_CRYPTO_SERVER_CONFIG_PROTOBUF_H_
|
