blob: 8413e0d974b673246e97d7d02d3f7698db23fc21 [file] [log] [blame]
// Copyright 2019 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/masque/masque_compression_engine.h"
#include <cstdint>
#include "absl/strings/string_view.h"
#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_data_reader.h"
#include "quic/core/quic_data_writer.h"
#include "quic/core/quic_framer.h"
#include "quic/core/quic_session.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_versions.h"
#include "quic/platform/api/quic_containers.h"
#include "common/platform/api/quiche_text_utils.h"
namespace quic {
namespace {
// |kFlowId0| is used to indicate creation of a new compression context.
const QuicDatagramFlowId kFlowId0 = 0;
enum MasqueAddressFamily : uint8_t {
MasqueAddressFamilyIPv4 = 4,
MasqueAddressFamilyIPv6 = 6,
};
} // namespace
MasqueCompressionEngine::MasqueCompressionEngine(
QuicSpdySession* masque_session)
: masque_session_(masque_session) {}
QuicDatagramFlowId MasqueCompressionEngine::FindOrCreateCompressionContext(
QuicConnectionId client_connection_id,
QuicConnectionId server_connection_id,
const QuicSocketAddress& server_address,
bool client_connection_id_present,
bool server_connection_id_present,
bool* validated) {
QuicDatagramFlowId flow_id = kFlowId0;
*validated = false;
for (const auto& kv : contexts_) {
const MasqueCompressionContext& context = kv.second;
if (context.server_address != server_address) {
continue;
}
if (client_connection_id_present &&
context.client_connection_id != client_connection_id) {
continue;
}
if (server_connection_id_present &&
context.server_connection_id != server_connection_id) {
continue;
}
flow_id = kv.first;
QUICHE_DCHECK_NE(flow_id, kFlowId0);
*validated = context.validated;
QUIC_DVLOG(1) << "Compressing using " << (*validated ? "" : "un")
<< "validated flow_id " << flow_id << " to "
<< context.server_address << " client "
<< context.client_connection_id << " server "
<< context.server_connection_id;
break;
}
if (flow_id != kFlowId0) {
// Found a compression context, use it.
return flow_id;
}
// Create new compression context.
flow_id = masque_session_->GetNextDatagramFlowId();
if (flow_id == kFlowId0) {
// Do not use value zero which is reserved in this mode.
flow_id = masque_session_->GetNextDatagramFlowId();
}
QUIC_DVLOG(1) << "Compression assigning new flow_id " << flow_id << " to "
<< server_address << " client " << client_connection_id
<< " server " << server_connection_id;
MasqueCompressionContext context;
context.client_connection_id = client_connection_id;
context.server_connection_id = server_connection_id;
context.server_address = server_address;
contexts_[flow_id] = context;
return flow_id;
}
bool MasqueCompressionEngine::WriteCompressedPacketToSlice(
QuicConnectionId client_connection_id,
QuicConnectionId server_connection_id,
const QuicSocketAddress& server_address,
QuicConnectionId destination_connection_id,
QuicConnectionId source_connection_id,
QuicDatagramFlowId flow_id,
bool validated,
uint8_t first_byte,
bool long_header,
QuicDataReader* reader,
QuicDataWriter* writer) {
if (validated) {
QUIC_DVLOG(1) << "Compressing using validated flow_id " << flow_id;
if (!writer->WriteVarInt62(flow_id)) {
QUIC_BUG(quic_bug_10981_1) << "Failed to write flow_id";
return false;
}
} else {
QUIC_DVLOG(1) << "Compressing using unvalidated flow_id " << flow_id;
if (!writer->WriteVarInt62(kFlowId0)) {
QUIC_BUG(quic_bug_10981_2) << "Failed to write kFlowId0";
return false;
}
if (!writer->WriteVarInt62(flow_id)) {
QUIC_BUG(quic_bug_10981_3) << "Failed to write flow_id";
return false;
}
if (!writer->WriteLengthPrefixedConnectionId(client_connection_id)) {
QUIC_BUG(quic_bug_10981_4) << "Failed to write client_connection_id";
return false;
}
if (!writer->WriteLengthPrefixedConnectionId(server_connection_id)) {
QUIC_BUG(quic_bug_10981_5) << "Failed to write server_connection_id";
return false;
}
if (!writer->WriteUInt16(server_address.port())) {
QUIC_BUG(quic_bug_10981_6) << "Failed to write port";
return false;
}
QuicIpAddress peer_ip = server_address.host();
QUICHE_DCHECK(peer_ip.IsInitialized());
std::string peer_ip_bytes = peer_ip.ToPackedString();
QUICHE_DCHECK(!peer_ip_bytes.empty());
uint8_t address_id;
if (peer_ip.address_family() == IpAddressFamily::IP_V6) {
address_id = MasqueAddressFamilyIPv6;
if (peer_ip_bytes.length() != QuicIpAddress::kIPv6AddressSize) {
QUIC_BUG(quic_bug_10981_7) << "Bad IPv6 length " << server_address;
return false;
}
} else if (peer_ip.address_family() == IpAddressFamily::IP_V4) {
address_id = MasqueAddressFamilyIPv4;
if (peer_ip_bytes.length() != QuicIpAddress::kIPv4AddressSize) {
QUIC_BUG(quic_bug_10981_8) << "Bad IPv4 length " << server_address;
return false;
}
} else {
QUIC_BUG(quic_bug_10981_9)
<< "Unexpected server_address " << server_address;
return false;
}
if (!writer->WriteUInt8(address_id)) {
QUIC_BUG(quic_bug_10981_10) << "Failed to write address_id";
return false;
}
if (!writer->WriteStringPiece(peer_ip_bytes)) {
QUIC_BUG(quic_bug_10981_11) << "Failed to write IP address";
return false;
}
}
if (!writer->WriteUInt8(first_byte)) {
QUIC_BUG(quic_bug_10981_12) << "Failed to write first_byte";
return false;
}
if (long_header) {
QuicVersionLabel version_label;
if (!reader->ReadUInt32(&version_label)) {
QUIC_DLOG(ERROR) << "Failed to read version";
return false;
}
if (!writer->WriteUInt32(version_label)) {
QUIC_BUG(quic_bug_10981_13) << "Failed to write version";
return false;
}
QuicConnectionId packet_destination_connection_id,
packet_source_connection_id;
if (!reader->ReadLengthPrefixedConnectionId(
&packet_destination_connection_id) ||
!reader->ReadLengthPrefixedConnectionId(&packet_source_connection_id)) {
QUIC_DLOG(ERROR) << "Failed to parse long header connection IDs";
return false;
}
if (packet_destination_connection_id != destination_connection_id) {
QUIC_DLOG(ERROR) << "Long header packet's destination_connection_id "
<< packet_destination_connection_id
<< " does not match expected "
<< destination_connection_id;
return false;
}
if (packet_source_connection_id != source_connection_id) {
QUIC_DLOG(ERROR) << "Long header packet's source_connection_id "
<< packet_source_connection_id
<< " does not match expected " << source_connection_id;
return false;
}
} else {
QuicConnectionId packet_destination_connection_id;
if (!reader->ReadConnectionId(&packet_destination_connection_id,
destination_connection_id.length())) {
QUIC_DLOG(ERROR)
<< "Failed to read short header packet's destination_connection_id";
return false;
}
if (packet_destination_connection_id != destination_connection_id) {
QUIC_DLOG(ERROR) << "Short header packet's destination_connection_id "
<< packet_destination_connection_id
<< " does not match expected "
<< destination_connection_id;
return false;
}
}
absl::string_view packet_payload = reader->ReadRemainingPayload();
if (!writer->WriteStringPiece(packet_payload)) {
QUIC_BUG(quic_bug_10981_14) << "Failed to write packet_payload";
return false;
}
return true;
}
void MasqueCompressionEngine::CompressAndSendPacket(
absl::string_view packet,
QuicConnectionId client_connection_id,
QuicConnectionId server_connection_id,
const QuicSocketAddress& server_address) {
QUIC_DVLOG(2) << "Compressing client " << client_connection_id << " server "
<< server_connection_id << "\n"
<< quiche::QuicheTextUtils::HexDump(packet);
QUICHE_DCHECK(server_address.IsInitialized());
if (packet.empty()) {
QUIC_BUG(quic_bug_10981_15) << "Tried to send empty packet";
return;
}
QuicDataReader reader(packet.data(), packet.length());
uint8_t first_byte;
if (!reader.ReadUInt8(&first_byte)) {
QUIC_BUG(quic_bug_10981_16) << "Failed to read first_byte";
return;
}
const bool long_header = (first_byte & FLAGS_LONG_HEADER) != 0;
bool client_connection_id_present = true, server_connection_id_present = true;
QuicConnectionId destination_connection_id, source_connection_id;
if (masque_session_->perspective() == Perspective::IS_SERVER) {
destination_connection_id = client_connection_id;
source_connection_id = server_connection_id;
if (!long_header) {
server_connection_id_present = false;
}
} else {
destination_connection_id = server_connection_id;
source_connection_id = client_connection_id;
if (!long_header) {
client_connection_id_present = false;
}
}
bool validated = false;
QuicDatagramFlowId flow_id = FindOrCreateCompressionContext(
client_connection_id, server_connection_id, server_address,
client_connection_id_present, server_connection_id_present, &validated);
size_t slice_length = packet.length() - destination_connection_id.length();
if (long_header) {
slice_length -= sizeof(uint8_t) * 2 + source_connection_id.length();
}
if (validated) {
slice_length += QuicDataWriter::GetVarInt62Len(flow_id);
} else {
slice_length += QuicDataWriter::GetVarInt62Len(kFlowId0) +
QuicDataWriter::GetVarInt62Len(flow_id) + sizeof(uint8_t) +
client_connection_id.length() + sizeof(uint8_t) +
server_connection_id.length() +
sizeof(server_address.port()) + sizeof(uint8_t) +
server_address.host().ToPackedString().length();
}
QuicUniqueBufferPtr buffer = MakeUniqueBuffer(
masque_session_->connection()->helper()->GetStreamSendBufferAllocator(),
slice_length);
QuicDataWriter writer(slice_length, buffer.get());
if (!WriteCompressedPacketToSlice(
client_connection_id, server_connection_id, server_address,
destination_connection_id, source_connection_id, flow_id, validated,
first_byte, long_header, &reader, &writer)) {
return;
}
QuicMemSlice slice(std::move(buffer), slice_length);
MessageResult message_result =
masque_session_->SendMessage(QuicMemSliceSpan(&slice));
QUIC_DVLOG(1) << "Sent packet compressed with flow ID " << flow_id
<< " and got message result " << message_result;
}
bool MasqueCompressionEngine::ParseCompressionContext(
QuicDataReader* reader,
MasqueCompressionContext* context) {
QuicDatagramFlowId new_flow_id;
if (!reader->ReadVarInt62(&new_flow_id)) {
QUIC_DLOG(ERROR) << "Could not read new_flow_id";
return false;
}
QuicConnectionId new_client_connection_id;
if (!reader->ReadLengthPrefixedConnectionId(&new_client_connection_id)) {
QUIC_DLOG(ERROR) << "Could not read new_client_connection_id";
return false;
}
QuicConnectionId new_server_connection_id;
if (!reader->ReadLengthPrefixedConnectionId(&new_server_connection_id)) {
QUIC_DLOG(ERROR) << "Could not read new_server_connection_id";
return false;
}
uint16_t port;
if (!reader->ReadUInt16(&port)) {
QUIC_DLOG(ERROR) << "Could not read port";
return false;
}
uint8_t address_id;
if (!reader->ReadUInt8(&address_id)) {
QUIC_DLOG(ERROR) << "Could not read address_id";
return false;
}
size_t ip_bytes_length;
if (address_id == MasqueAddressFamilyIPv6) {
ip_bytes_length = QuicIpAddress::kIPv6AddressSize;
} else if (address_id == MasqueAddressFamilyIPv4) {
ip_bytes_length = QuicIpAddress::kIPv4AddressSize;
} else {
QUIC_DLOG(ERROR) << "Unknown address_id " << static_cast<int>(address_id);
return false;
}
char ip_bytes[QuicIpAddress::kMaxAddressSize];
if (!reader->ReadBytes(ip_bytes, ip_bytes_length)) {
QUIC_DLOG(ERROR) << "Could not read IP address";
return false;
}
QuicIpAddress ip_address;
ip_address.FromPackedString(ip_bytes, ip_bytes_length);
if (!ip_address.IsInitialized()) {
QUIC_BUG(quic_bug_10981_17) << "Failed to parse IP address";
return false;
}
QuicSocketAddress new_server_address = QuicSocketAddress(ip_address, port);
auto context_pair = contexts_.find(new_flow_id);
if (context_pair == contexts_.end()) {
context->client_connection_id = new_client_connection_id;
context->server_connection_id = new_server_connection_id;
context->server_address = new_server_address;
context->validated = true;
contexts_[new_flow_id] = *context;
QUIC_DVLOG(1) << "Registered new flow_id " << new_flow_id << " to "
<< new_server_address << " client "
<< new_client_connection_id << " server "
<< new_server_connection_id;
} else {
*context = context_pair->second;
if (context->client_connection_id != new_client_connection_id) {
QUIC_LOG(ERROR)
<< "Received incorrect context registration for existing flow_id "
<< new_flow_id << " mismatched client "
<< context->client_connection_id << " " << new_client_connection_id;
return false;
}
if (context->server_connection_id != new_server_connection_id) {
QUIC_LOG(ERROR)
<< "Received incorrect context registration for existing flow_id "
<< new_flow_id << " mismatched server "
<< context->server_connection_id << " " << new_server_connection_id;
return false;
}
if (context->server_address != new_server_address) {
QUIC_LOG(ERROR)
<< "Received incorrect context registration for existing flow_id "
<< new_flow_id << " mismatched server " << context->server_address
<< " " << new_server_address;
return false;
}
if (!context->validated) {
context->validated = true;
contexts_[new_flow_id] = *context;
QUIC_DLOG(INFO) << "Successfully validated remotely-unvalidated flow_id "
<< new_flow_id << " to " << new_server_address
<< " client " << new_client_connection_id << " server "
<< new_server_connection_id;
} else {
QUIC_DVLOG(1) << "Decompressing using incoming locally-validated "
"remotely-unvalidated flow_id "
<< new_flow_id << " to " << new_server_address << " client "
<< new_client_connection_id << " server "
<< new_server_connection_id;
}
}
return true;
}
bool MasqueCompressionEngine::WriteDecompressedPacket(
QuicDataReader* reader,
const MasqueCompressionContext& context,
std::vector<char>* packet,
bool* version_present) {
QuicConnectionId destination_connection_id, source_connection_id;
if (masque_session_->perspective() == Perspective::IS_SERVER) {
destination_connection_id = context.server_connection_id;
source_connection_id = context.client_connection_id;
} else {
destination_connection_id = context.client_connection_id;
source_connection_id = context.server_connection_id;
}
size_t packet_length =
reader->BytesRemaining() + destination_connection_id.length();
uint8_t first_byte;
if (!reader->ReadUInt8(&first_byte)) {
QUIC_DLOG(ERROR) << "Failed to read first_byte";
return false;
}
*version_present = (first_byte & FLAGS_LONG_HEADER) != 0;
if (*version_present) {
packet_length += sizeof(uint8_t) * 2 + source_connection_id.length();
}
*packet = std::vector<char>(packet_length);
QuicDataWriter writer(packet->size(), packet->data());
if (!writer.WriteUInt8(first_byte)) {
QUIC_BUG(quic_bug_10981_18) << "Failed to write first_byte";
return false;
}
if (*version_present) {
QuicVersionLabel version_label;
if (!reader->ReadUInt32(&version_label)) {
QUIC_DLOG(ERROR) << "Failed to read version";
return false;
}
if (!writer.WriteUInt32(version_label)) {
QUIC_BUG(quic_bug_10981_19) << "Failed to write version";
return false;
}
if (!writer.WriteLengthPrefixedConnectionId(destination_connection_id)) {
QUIC_BUG(quic_bug_10981_20)
<< "Failed to write long header destination_connection_id";
return false;
}
if (!writer.WriteLengthPrefixedConnectionId(source_connection_id)) {
QUIC_BUG(quic_bug_10981_21)
<< "Failed to write long header source_connection_id";
return false;
}
} else {
if (!writer.WriteConnectionId(destination_connection_id)) {
QUIC_BUG(quic_bug_10981_22)
<< "Failed to write short header destination_connection_id";
return false;
}
}
absl::string_view payload = reader->ReadRemainingPayload();
if (!writer.WriteStringPiece(payload)) {
QUIC_BUG(quic_bug_10981_23) << "Failed to write payload";
return false;
}
return true;
}
bool MasqueCompressionEngine::DecompressDatagram(
absl::string_view datagram,
QuicConnectionId* client_connection_id,
QuicConnectionId* server_connection_id,
QuicSocketAddress* server_address,
std::vector<char>* packet,
bool* version_present) {
QUIC_DVLOG(1) << "Decompressing DATAGRAM frame of length "
<< datagram.length();
QuicDataReader reader(datagram);
QuicDatagramFlowId flow_id;
if (!reader.ReadVarInt62(&flow_id)) {
QUIC_DLOG(ERROR) << "Could not read flow_id";
return false;
}
MasqueCompressionContext context;
if (flow_id == kFlowId0) {
if (!ParseCompressionContext(&reader, &context)) {
return false;
}
} else {
auto context_pair = contexts_.find(flow_id);
if (context_pair == contexts_.end()) {
QUIC_DLOG(ERROR) << "Received unknown flow_id " << flow_id;
return false;
}
context = context_pair->second;
if (!context.validated) {
context.validated = true;
contexts_[flow_id] = context;
QUIC_DLOG(INFO) << "Successfully validated remotely-validated flow_id "
<< flow_id << " to " << context.server_address
<< " client " << context.client_connection_id
<< " server " << context.server_connection_id;
} else {
QUIC_DVLOG(1) << "Decompressing using incoming locally-validated "
"remotely-validated flow_id "
<< flow_id << " to " << context.server_address << " client "
<< context.client_connection_id << " server "
<< context.server_connection_id;
}
}
if (!WriteDecompressedPacket(&reader, context, packet, version_present)) {
return false;
}
*server_address = context.server_address;
*client_connection_id = context.client_connection_id;
*server_connection_id = context.server_connection_id;
QUIC_DVLOG(2) << "Decompressed client " << context.client_connection_id
<< " server " << context.server_connection_id << "\n"
<< quiche::QuicheTextUtils::HexDump(
absl::string_view(packet->data(), packet->size()));
return true;
}
void MasqueCompressionEngine::UnregisterClientConnectionId(
QuicConnectionId client_connection_id) {
std::vector<QuicDatagramFlowId> flow_ids_to_remove;
for (const auto& kv : contexts_) {
const MasqueCompressionContext& context = kv.second;
if (context.client_connection_id == client_connection_id) {
flow_ids_to_remove.push_back(kv.first);
}
}
for (QuicDatagramFlowId flow_id : flow_ids_to_remove) {
contexts_.erase(flow_id);
}
}
} // namespace quic