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
146
147
148
149
150
151
152
153
|
// Copyright (c) 2020 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.
#include "quic/core/quic_legacy_version_encapsulator.h"
#include "quic/core/crypto/crypto_handshake_message.h"
#include "quic/core/crypto/crypto_protocol.h"
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_bug_tracker.h"
namespace quic {
QuicLegacyVersionEncapsulator::QuicLegacyVersionEncapsulator(
QuicPacketBuffer packet_buffer)
: packet_buffer_(packet_buffer) {}
QuicLegacyVersionEncapsulator::~QuicLegacyVersionEncapsulator() {}
// static
QuicByteCount QuicLegacyVersionEncapsulator::GetMinimumOverhead(
absl::string_view sni) {
// The number 52 is the sum of:
// - Flags (1 byte)
// - Server Connection ID (8 bytes)
// - Version (4 bytes)
// - Packet Number (1 byte)
// - Message Authentication Hash (12 bytes)
// - Frame Type (1 byte)
// - Stream ID (1 byte)
// - ClientHello tag (4 bytes)
// - ClientHello num tags (2 bytes)
// - Padding (2 bytes)
// - SNI tag (4 bytes)
// - SNI end offset (4 bytes)
// - QLVE tag (4 bytes)
// - QLVE end offset (4 bytes)
return 52 + sni.length();
}
QuicPacketBuffer QuicLegacyVersionEncapsulator::GetPacketBuffer() {
return packet_buffer_;
}
void QuicLegacyVersionEncapsulator::OnSerializedPacket(
SerializedPacket serialized_packet) {
if (encrypted_length_ != 0) {
unrecoverable_failure_encountered_ = true;
QUIC_BUG(quic_bug_10615_1) << "OnSerializedPacket called twice";
return;
}
if (serialized_packet.encrypted_length == 0) {
unrecoverable_failure_encountered_ = true;
QUIC_BUG(quic_bug_10615_2) << "OnSerializedPacket called with empty packet";
return;
}
encrypted_length_ = serialized_packet.encrypted_length;
}
void QuicLegacyVersionEncapsulator::OnUnrecoverableError(
QuicErrorCode error,
const std::string& error_details) {
unrecoverable_failure_encountered_ = true;
QUIC_BUG(quic_bug_10615_3) << "QuicLegacyVersionEncapsulator received error "
<< error << ": " << error_details;
}
bool QuicLegacyVersionEncapsulator::ShouldGeneratePacket(
HasRetransmittableData /*retransmittable*/,
IsHandshake /*handshake*/) {
return true;
}
const QuicFrames
QuicLegacyVersionEncapsulator::MaybeBundleAckOpportunistically() {
// We do not want to ever include any ACKs here, return an empty array.
return QuicFrames();
}
SerializedPacketFate QuicLegacyVersionEncapsulator::GetSerializedPacketFate(
bool /*is_mtu_discovery*/,
EncryptionLevel /*encryption_level*/) {
return SEND_TO_WRITER;
}
// static
QuicPacketLength QuicLegacyVersionEncapsulator::Encapsulate(
absl::string_view sni,
absl::string_view inner_packet,
const QuicConnectionId& server_connection_id,
QuicTime creation_time,
QuicByteCount outer_max_packet_length,
char* out) {
if (outer_max_packet_length > kMaxOutgoingPacketSize) {
outer_max_packet_length = kMaxOutgoingPacketSize;
}
CryptoHandshakeMessage outer_chlo;
outer_chlo.set_tag(kCHLO);
outer_chlo.SetStringPiece(kSNI, sni);
outer_chlo.SetStringPiece(kQLVE, inner_packet);
const QuicData& serialized_outer_chlo = outer_chlo.GetSerialized();
QUICHE_DCHECK(!LegacyVersionForEncapsulation().UsesCryptoFrames());
QUICHE_DCHECK(LegacyVersionForEncapsulation().UsesQuicCrypto());
QuicStreamFrame outer_stream_frame(
QuicUtils::GetCryptoStreamId(
LegacyVersionForEncapsulation().transport_version),
/*fin=*/false,
/*offset=*/0, serialized_outer_chlo.AsStringPiece());
QuicFramer outer_framer(
ParsedQuicVersionVector{LegacyVersionForEncapsulation()}, creation_time,
Perspective::IS_CLIENT, kQuicDefaultConnectionIdLength);
outer_framer.SetInitialObfuscators(server_connection_id);
char outer_encrypted_packet[kMaxOutgoingPacketSize];
QuicPacketBuffer outer_packet_buffer(outer_encrypted_packet, nullptr);
QuicLegacyVersionEncapsulator creator_delegate(outer_packet_buffer);
QuicPacketCreator outer_creator(server_connection_id, &outer_framer,
&creator_delegate);
outer_creator.SetMaxPacketLength(outer_max_packet_length);
outer_creator.set_encryption_level(ENCRYPTION_INITIAL);
outer_creator.SetTransmissionType(NOT_RETRANSMISSION);
if (!outer_creator.AddPaddedSavedFrame(QuicFrame(outer_stream_frame),
NOT_RETRANSMISSION)) {
QUIC_BUG(quic_bug_10615_4)
<< "Failed to add Legacy Version Encapsulation stream frame "
"(max packet length is "
<< outer_creator.max_packet_length() << ") " << outer_stream_frame;
return 0;
}
outer_creator.FlushCurrentPacket();
const QuicPacketLength encrypted_length = creator_delegate.encrypted_length_;
if (creator_delegate.unrecoverable_failure_encountered_ ||
encrypted_length == 0) {
QUIC_BUG(quic_bug_10615_5)
<< "Failed to perform Legacy Version Encapsulation of "
<< inner_packet.length() << " bytes";
return 0;
}
if (encrypted_length > kMaxOutgoingPacketSize) {
QUIC_BUG(quic_bug_10615_6)
<< "Legacy Version Encapsulation outer creator generated a "
"packet with unexpected length "
<< encrypted_length;
return 0;
}
QUIC_DLOG(INFO) << "Successfully performed Legacy Version Encapsulation from "
<< inner_packet.length() << " bytes to " << encrypted_length;
// Replace our current packet with the encapsulated one.
memcpy(out, outer_encrypted_packet, encrypted_length);
return encrypted_length;
}
} // namespace quic
|
