#include <tls_extensions_12.h>

Inheritance diagram for Botan::TLS::Supported_Point_Formats:

Public Types
enum	ECPointFormat : uint8_t { UNCOMPRESSED = 0 , ANSIX962_COMPRESSED_PRIME = 1 , ANSIX962_COMPRESSED_CHAR2 = 2 }

Public Member Functions
bool	empty () const override
virtual bool	is_implemented () const
bool	prefers_compressed () const
std::vector< uint8_t >	serialize (Connection_Side whoami) const override
	Supported_Point_Formats (bool prefer_compressed)
	Supported_Point_Formats (TLS_Data_Reader &reader, uint16_t extension_size)
Extension_Code	type () const override

Static Public Member Functions
static Extension_Code	static_type ()

Detailed Description

Supported Point Formats Extension (RFC 4492)

Definition at line 91 of file tls_extensions_12.h.

Member Enumeration Documentation

◆ ECPointFormat

enum Botan::TLS::Supported_Point_Formats::ECPointFormat : uint8_t

Enumerator
UNCOMPRESSED
ANSIX962_COMPRESSED_PRIME
ANSIX962_COMPRESSED_CHAR2

Definition at line 93 of file tls_extensions_12.h.

                         : uint8_t /* NOLINT(*-use-enum-class) */ {
         UNCOMPRESSED = 0,
         ANSIX962_COMPRESSED_PRIME = 1,
         ANSIX962_COMPRESSED_CHAR2 = 2,  // don't support these curves
      };

Constructor & Destructor Documentation

◆ Supported_Point_Formats() [1/2]

Botan::TLS::Supported_Point_Formats::Supported_Point_Formats ( bool prefer_compressed )

inlineexplicit

Definition at line 105 of file tls_extensions_12.h.

105: m_prefers_compressed(prefer_compressed) {}

◆ Supported_Point_Formats() [2/2]

Botan::TLS::Supported_Point_Formats::Supported_Point_Formats	(	TLS_Data_Reader &	reader,
		uint16_t	extension_size )

Definition at line 45 of file tls_extensions_12.cpp.

                                                                                                 {
   const uint8_t len = reader.get_byte();
 
   if(len + 1 != extension_size) {
      throw Decoding_Error("Inconsistent length field in supported point formats list");
   }
 
   bool includes_uncompressed = false;
   for(size_t i = 0; i != len; ++i) {
      const uint8_t format = reader.get_byte();
 
      if(static_cast<ECPointFormat>(format) == UNCOMPRESSED) {
         m_prefers_compressed = false;
         reader.discard_next(len - i - 1);
         return;
      } else if(static_cast<ECPointFormat>(format) == ANSIX962_COMPRESSED_PRIME) {
         m_prefers_compressed = true;
         std::vector<uint8_t> remaining_formats = reader.get_fixed<uint8_t>(len - i - 1);
         includes_uncompressed =
            std::any_of(std::begin(remaining_formats), std::end(remaining_formats), [](uint8_t remaining_format) {
               return static_cast<ECPointFormat>(remaining_format) == UNCOMPRESSED;
            });
         break;
      }
 
      // ignore ANSIX962_COMPRESSED_CHAR2, we don't support these curves
   }
 
   // RFC 4492 5.1.:
   //   If the Supported Point Formats Extension is indeed sent, it MUST contain the value 0 (uncompressed)
   //   as one of the items in the list of point formats.
   // Note:
   //   RFC 8422 5.1.2. explicitly requires this check,
   //   but only if the Supported Groups extension was sent.
   if(!includes_uncompressed) {
      throw TLS_Exception(Alert::IllegalParameter,
                          "Supported Point Formats Extension must contain the uncompressed point format");
   }
}

References ANSIX962_COMPRESSED_PRIME, Botan::TLS::TLS_Data_Reader::discard_next(), Botan::TLS::TLS_Data_Reader::get_byte(), Botan::TLS::TLS_Data_Reader::get_fixed(), and UNCOMPRESSED.

Member Function Documentation

◆ empty()

bool Botan::TLS::Supported_Point_Formats::empty ( ) const

inlineoverridevirtual

Predicate if a TLS extension should be included or not

Returns: true if this extension should be encoded, otherwise false

Implements Botan::TLS::Extension.

Definition at line 109 of file tls_extensions_12.h.

109{ return false; }

◆ is_implemented()

virtual bool Botan::TLS::Extension::is_implemented ( ) const

inlinevirtualinherited

Predicate if the extension is known/implemented

Note: this exists primarily to support unknown extension handling and doesn't need to be overridden even in the custom extension case.

Returns: true if this extension is known

Reimplemented in Botan::TLS::Unknown_Extension.

Definition at line 113 of file tls_extensions.h.

113{ return true; }

◆ prefers_compressed()

bool Botan::TLS::Supported_Point_Formats::prefers_compressed ( ) const

inline

Definition at line 111 of file tls_extensions_12.h.

111{ return m_prefers_compressed; }

◆ serialize()

std::vector< uint8_t > Botan::TLS::Supported_Point_Formats::serialize ( Connection_Side whoami ) const

overridevirtual

Serialize a TLS extension

Parameters

whoami which peer we are acting as in the protocol

Returns: serialized binary for the extension

Implements Botan::TLS::Extension.

Definition at line 36 of file tls_extensions_12.cpp.

                                                                             {
   // if this extension is sent, it MUST include uncompressed (RFC 4492, section 5.1)
   if(m_prefers_compressed) {
      return std::vector<uint8_t>{2, ANSIX962_COMPRESSED_PRIME, UNCOMPRESSED};
   } else {
      return std::vector<uint8_t>{1, UNCOMPRESSED};
   }
}