blob: 9e1f9d3be3f2093e07bb4bec4d6d0ad7a599603b (
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
|
// 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 <stddef.h>
#include <stdint.h>
#include <string>
#include <vector>
#include "base/logging.h"
#include "base/macros.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(const 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_t primary_time() const { return primary_time_; }
void set_primary_time(int64_t primary_time) { primary_time_ = primary_time; }
bool has_priority() const { return priority_ > 0; }
uint64_t priority() const { return priority_; }
void set_priority(int64_t 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_t 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_t 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_
|
