quic/core/crypto/transport_parameters.h - quiche - Git at Google

 // Copyright (c) 2018 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 QUICHE_QUIC_CORE_CRYPTO_TRANSPORT_PARAMETERS_H_
 #define QUICHE_QUIC_CORE_CRYPTO_TRANSPORT_PARAMETERS_H_

 #include <memory>
 #include <vector>

 #include "third_party/boringssl/src/include/openssl/bytestring.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"

 namespace quic {

 // TransportParameters contains parameters for QUIC's transport layer that are
 // exchanged during the TLS handshake. This struct is a mirror of the struct in
 // the "Transport Parameter Encoding" section of draft-ietf-quic-transport.
 // This struct currently uses the values from draft 20.
 struct QUIC_EXPORT_PRIVATE TransportParameters {
   // The identifier used to differentiate transport parameters.
   enum TransportParameterId : uint16_t;
   // Represents an individual QUIC transport parameter that only encodes a
   // variable length integer. Can only be created inside the constructor for
   // TransportParameters.
   class QUIC_EXPORT_PRIVATE IntegerParameter {
    public:
     // Forbid constructing and copying apart from TransportParameters.
     IntegerParameter() = delete;
     IntegerParameter(const IntegerParameter&) = delete;
     IntegerParameter& operator=(const IntegerParameter&) = delete;
     // Sets the value of this transport parameter.
     void set_value(uint64_t value);
     // Gets the value of this transport parameter.
     uint64_t value() const;
     // Validates whether the current value is valid.
     bool IsValid() const;
     // Writes to a crypto byte buffer, used during serialization. Does not write
     // anything if the value is equal to the parameter's default value.
     // Returns whether the write was successful.
     bool WriteToCbb(CBB* parent_cbb) const;
     // Reads from a crypto byte string, used during parsing.
     // Returns whether the read was successful.
     bool ReadFromCbs(CBS* const value_cbs);
     // operator<< allows easily logging integer transport parameters.
     friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
         std::ostream& os,
         const IntegerParameter& param);

    private:
     friend struct TransportParameters;
     // Constructors for initial setup used by TransportParameters only.
     // This constructor sets |default_value| and |min_value| to 0, and
     // |max_value| to kVarInt62MaxValue.
     explicit IntegerParameter(TransportParameterId param_id);
     IntegerParameter(TransportParameterId param_id,
                      uint64_t default_value,
                      uint64_t min_value,
                      uint64_t max_value);
     // Human-readable string representation.
     std::string ToString(bool for_use_in_list) const;

     // Number used to indicate this transport parameter.
     TransportParameterId param_id_;
     // Current value of the transport parameter.
     uint64_t value_;
     // Default value of this transport parameter, as per IETF specification.
     const uint64_t default_value_;
     // Minimum value of this transport parameter, as per IETF specification.
     const uint64_t min_value_;
     // Maximum value of this transport parameter, as per IETF specification.
     const uint64_t max_value_;
     // Ensures this parameter is not parsed twice in the same message.
     bool has_been_read_from_cbs_;
   };

   // Represents the preferred_address transport parameter that a server can
   // send to clients.
   struct QUIC_EXPORT_PRIVATE PreferredAddress {
     PreferredAddress();
     ~PreferredAddress();

     QuicSocketAddress ipv4_socket_address;
     QuicSocketAddress ipv6_socket_address;
     QuicConnectionId connection_id;
     std::vector<uint8_t> stateless_reset_token;

     // Allows easily logging.
     std::string ToString() const;
     friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
         std::ostream& os,
         const TransportParameters& params);
   };

   TransportParameters();
   ~TransportParameters();

   // Represents the sender of the transport parameters. When |perspective| is
   // Perspective::IS_CLIENT, this struct is being used in the client_hello
   // handshake message; when it is Perspective::IS_SERVER, it is being used in
   // the encrypted_extensions handshake message.
   Perspective perspective;

   // When Perspective::IS_CLIENT, |version| is the initial version offered by
   // the client (before any version negotiation packets) for this connection.
   // When Perspective::IS_SERVER, |version| is the version that is in use.
   QuicVersionLabel version;

   // |supported_versions| contains a list of all versions that the server would
   // send in a version negotiation packet. It is not used if |perspective ==
   // Perspective::IS_CLIENT|.
   QuicVersionLabelVector supported_versions;

   // The value of the Destination Connection ID field from the first
   // Initial packet sent by the client.
   QuicConnectionId original_connection_id;

   // Idle timeout expressed in milliseconds.
   IntegerParameter idle_timeout_milliseconds;

   // Stateless reset token used in verifying stateless resets.
   std::vector<uint8_t> stateless_reset_token;

   // Limits the size of packets that the endpoint is willing to receive.
   // This indicates that packets larger than this limit will be dropped.
   IntegerParameter max_packet_size;

   // Contains the initial value for the maximum amount of data that can
   // be sent on the connection.
   IntegerParameter initial_max_data;

   // Initial flow control limit for locally-initiated bidirectional streams.
   IntegerParameter initial_max_stream_data_bidi_local;

   // Initial flow control limit for peer-initiated bidirectional streams.
   IntegerParameter initial_max_stream_data_bidi_remote;

   // Initial flow control limit for unidirectional streams.
   IntegerParameter initial_max_stream_data_uni;

   // Initial maximum number of bidirectional streams the peer may initiate.
   IntegerParameter initial_max_streams_bidi;

   // Initial maximum number of unidirectional streams the peer may initiate.
   IntegerParameter initial_max_streams_uni;

   // Exponent used to decode the ACK Delay field in ACK frames.
   IntegerParameter ack_delay_exponent;

   // Maximum amount of time in milliseconds by which the endpoint will
   // delay sending acknowledgments.
   IntegerParameter max_ack_delay;

   // Indicates lack of support for connection migration.
   bool disable_migration;

   // Used to effect a change in server address at the end of the handshake.
   std::unique_ptr<PreferredAddress> preferred_address;

   // Maximum number of connection IDs from the peer that an endpoint is willing
   // to store.
   IntegerParameter active_connection_id_limit;

   // Transport parameters used by Google QUIC but not IETF QUIC. This is
   // serialized into a TransportParameter struct with a TransportParameterId of
   // kGoogleQuicParamId.
   std::unique_ptr<CryptoHandshakeMessage> google_quic_params;

   // Validates whether transport parameters are valid according to
   // the specification.
   bool AreValid() const;

   // Allows easily logging transport parameters.
   std::string ToString() const;
   friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
       std::ostream& os,
       const TransportParameters& params);
 };

 // Serializes a TransportParameters struct into the format for sending it in a
 // TLS extension. The serialized bytes are written to |*out|. Returns if the
 // parameters are valid and serialization succeeded.
 QUIC_EXPORT_PRIVATE bool SerializeTransportParameters(
     const TransportParameters& in,
     std::vector<uint8_t>* out);

 // Parses bytes from the quic_transport_parameters TLS extension and writes the
 // parsed parameters into |*out|. Input is read from |in| for |in_len| bytes.
 // |perspective| indicates whether the input came from a client or a server.
 // This method returns true if the input was successfully parsed.
 // TODO(nharper): Write fuzz tests for this method.
 QUIC_EXPORT_PRIVATE bool ParseTransportParameters(const uint8_t* in,
                                                   size_t in_len,
                                                   Perspective perspective,
                                                   TransportParameters* out);

 }  // namespace quic

 #endif  // QUICHE_QUIC_CORE_CRYPTO_TRANSPORT_PARAMETERS_H_
	// Copyright (c) 2018 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 QUICHE_QUIC_CORE_CRYPTO_TRANSPORT_PARAMETERS_H_
	#define QUICHE_QUIC_CORE_CRYPTO_TRANSPORT_PARAMETERS_H_

	#include <memory>
	#include <vector>

	#include "third_party/boringssl/src/include/openssl/bytestring.h"
	#include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
	#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
	#include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
	#include "net/third_party/quiche/src/quic/core/quic_types.h"
	#include "net/third_party/quiche/src/quic/core/quic_versions.h"

	namespace quic {

	// TransportParameters contains parameters for QUIC's transport layer that are
	// exchanged during the TLS handshake. This struct is a mirror of the struct in
	// the "Transport Parameter Encoding" section of draft-ietf-quic-transport.
	// This struct currently uses the values from draft 20.
	struct QUIC_EXPORT_PRIVATE TransportParameters {
	// The identifier used to differentiate transport parameters.
	enum TransportParameterId : uint16_t;
	// Represents an individual QUIC transport parameter that only encodes a
	// variable length integer. Can only be created inside the constructor for
	// TransportParameters.
	class QUIC_EXPORT_PRIVATE IntegerParameter {
	public:
	// Forbid constructing and copying apart from TransportParameters.
	IntegerParameter() = delete;
	IntegerParameter(const IntegerParameter&) = delete;
	IntegerParameter& operator=(const IntegerParameter&) = delete;
	// Sets the value of this transport parameter.
	void set_value(uint64_t value);
	// Gets the value of this transport parameter.
	uint64_t value() const;
	// Validates whether the current value is valid.
	bool IsValid() const;
	// Writes to a crypto byte buffer, used during serialization. Does not write
	// anything if the value is equal to the parameter's default value.
	// Returns whether the write was successful.
	bool WriteToCbb(CBB* parent_cbb) const;
	// Reads from a crypto byte string, used during parsing.
	// Returns whether the read was successful.
	bool ReadFromCbs(CBS* const value_cbs);
	// operator<< allows easily logging integer transport parameters.
	friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
	std::ostream& os,
	const IntegerParameter& param);

	private:
	friend struct TransportParameters;
	// Constructors for initial setup used by TransportParameters only.
	// This constructor sets \|default_value\| and \|min_value\| to 0, and
	// \|max_value\| to kVarInt62MaxValue.
	explicit IntegerParameter(TransportParameterId param_id);
	IntegerParameter(TransportParameterId param_id,
	uint64_t default_value,
	uint64_t min_value,
	uint64_t max_value);
	// Human-readable string representation.
	std::string ToString(bool for_use_in_list) const;

	// Number used to indicate this transport parameter.
	TransportParameterId param_id_;
	// Current value of the transport parameter.
	uint64_t value_;
	// Default value of this transport parameter, as per IETF specification.
	const uint64_t default_value_;
	// Minimum value of this transport parameter, as per IETF specification.
	const uint64_t min_value_;
	// Maximum value of this transport parameter, as per IETF specification.
	const uint64_t max_value_;
	// Ensures this parameter is not parsed twice in the same message.
	bool has_been_read_from_cbs_;
	};

	// Represents the preferred_address transport parameter that a server can
	// send to clients.
	struct QUIC_EXPORT_PRIVATE PreferredAddress {
	PreferredAddress();
	~PreferredAddress();

	QuicSocketAddress ipv4_socket_address;
	QuicSocketAddress ipv6_socket_address;
	QuicConnectionId connection_id;
	std::vector<uint8_t> stateless_reset_token;

	// Allows easily logging.
	std::string ToString() const;
	friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
	std::ostream& os,
	const TransportParameters& params);
	};

	TransportParameters();
	~TransportParameters();

	// Represents the sender of the transport parameters. When \|perspective\| is
	// Perspective::IS_CLIENT, this struct is being used in the client_hello
	// handshake message; when it is Perspective::IS_SERVER, it is being used in
	// the encrypted_extensions handshake message.
	Perspective perspective;

	// When Perspective::IS_CLIENT, \|version\| is the initial version offered by
	// the client (before any version negotiation packets) for this connection.
	// When Perspective::IS_SERVER, \|version\| is the version that is in use.
	QuicVersionLabel version;

	// \|supported_versions\| contains a list of all versions that the server would
	// send in a version negotiation packet. It is not used if \|perspective ==
	// Perspective::IS_CLIENT\|.
	QuicVersionLabelVector supported_versions;

	// The value of the Destination Connection ID field from the first
	// Initial packet sent by the client.
	QuicConnectionId original_connection_id;

	// Idle timeout expressed in milliseconds.
	IntegerParameter idle_timeout_milliseconds;

	// Stateless reset token used in verifying stateless resets.
	std::vector<uint8_t> stateless_reset_token;

	// Limits the size of packets that the endpoint is willing to receive.
	// This indicates that packets larger than this limit will be dropped.
	IntegerParameter max_packet_size;

	// Contains the initial value for the maximum amount of data that can
	// be sent on the connection.
	IntegerParameter initial_max_data;

	// Initial flow control limit for locally-initiated bidirectional streams.
	IntegerParameter initial_max_stream_data_bidi_local;

	// Initial flow control limit for peer-initiated bidirectional streams.
	IntegerParameter initial_max_stream_data_bidi_remote;

	// Initial flow control limit for unidirectional streams.
	IntegerParameter initial_max_stream_data_uni;

	// Initial maximum number of bidirectional streams the peer may initiate.
	IntegerParameter initial_max_streams_bidi;

	// Initial maximum number of unidirectional streams the peer may initiate.
	IntegerParameter initial_max_streams_uni;

	// Exponent used to decode the ACK Delay field in ACK frames.
	IntegerParameter ack_delay_exponent;

	// Maximum amount of time in milliseconds by which the endpoint will
	// delay sending acknowledgments.
	IntegerParameter max_ack_delay;

	// Indicates lack of support for connection migration.
	bool disable_migration;

	// Used to effect a change in server address at the end of the handshake.
	std::unique_ptr<PreferredAddress> preferred_address;

	// Maximum number of connection IDs from the peer that an endpoint is willing
	// to store.
	IntegerParameter active_connection_id_limit;

	// Transport parameters used by Google QUIC but not IETF QUIC. This is
	// serialized into a TransportParameter struct with a TransportParameterId of
	// kGoogleQuicParamId.
	std::unique_ptr<CryptoHandshakeMessage> google_quic_params;

	// Validates whether transport parameters are valid according to
	// the specification.
	bool AreValid() const;

	// Allows easily logging transport parameters.
	std::string ToString() const;
	friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
	std::ostream& os,
	const TransportParameters& params);
	};

	// Serializes a TransportParameters struct into the format for sending it in a
	// TLS extension. The serialized bytes are written to \|*out\|. Returns if the
	// parameters are valid and serialization succeeded.
	QUIC_EXPORT_PRIVATE bool SerializeTransportParameters(
	const TransportParameters& in,
	std::vector<uint8_t>* out);

	// Parses bytes from the quic_transport_parameters TLS extension and writes the
	// parsed parameters into \|*out\|. Input is read from \|in\| for \|in_len\| bytes.
	// \|perspective\| indicates whether the input came from a client or a server.
	// This method returns true if the input was successfully parsed.
	// TODO(nharper): Write fuzz tests for this method.
	QUIC_EXPORT_PRIVATE bool ParseTransportParameters(const uint8_t* in,
	size_t in_len,
	Perspective perspective,
	TransportParameters* out);

	} // namespace quic

	#endif // QUICHE_QUIC_CORE_CRYPTO_TRANSPORT_PARAMETERS_H_