#include <tls_extensions.h>

Inheritance diagram for Botan::TLS::Supported_Groups:

Public Member Functions
std::vector< Group_Params >	dh_groups () const
std::vector< Group_Params >	ec_groups () const
bool	empty () const override
const std::vector< Group_Params > &	groups () const
virtual bool	is_implemented () const
std::vector< uint8_t >	serialize (Connection_Side whoami) const override
	Supported_Groups (const std::vector< Group_Params > &groups)
	Supported_Groups (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 Groups Extension (RFC 7919)

Definition at line 317 of file tls_extensions.h.

Constructor & Destructor Documentation

◆ Supported_Groups() [1/2]

Botan::TLS::Supported_Groups::Supported_Groups ( const std::vector< Group_Params > & groups )

explicit

Definition at line 497 of file tls_extensions.cpp.

497: m_groups(groups) {}

Botan::TLS::Supported_Groups::groups

const std::vector< Group_Params > & groups() const

Definition tls_extensions.cpp:499

References groups().

◆ Supported_Groups() [2/2]

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

Definition at line 541 of file tls_extensions.cpp.

                                                                                   {
   const uint16_t len = reader.get_uint16_t();
 
   if(len + 2 != extension_size) {
      throw Decoding_Error("Inconsistent length field in supported groups list");
   }
 
   if(len % 2 == 1) {
      throw Decoding_Error("Supported groups list of strange size");
   }
 
   const size_t elems = len / 2;
 
   for(size_t i = 0; i != elems; ++i) {
      const auto group = static_cast<Group_Params>(reader.get_uint16_t());
      // Note: RFC 8446 does not explicitly enforce that groups must be unique.
      if(!value_exists(m_groups, group)) {
         m_groups.push_back(group);
      }
   }
}

References Botan::TLS::TLS_Data_Reader::get_uint16_t(), and Botan::value_exists().

Member Function Documentation

◆ dh_groups()

std::vector< Group_Params > Botan::TLS::Supported_Groups::dh_groups ( ) const

Definition at line 513 of file tls_extensions.cpp.

                                                          {
   std::vector<Group_Params> dh;
   for(auto g : m_groups) {
      if(g.is_in_ffdhe_range()) {
         dh.push_back(g);
      }
   }
   return dh;
}

◆ ec_groups()

std::vector< Group_Params > Botan::TLS::Supported_Groups::ec_groups ( ) const

Definition at line 503 of file tls_extensions.cpp.

                                                          {
   std::vector<Group_Params> ec;
   for(auto g : m_groups) {
      if(g.is_pure_ecc_group()) {
         ec.push_back(g);
      }
   }
   return ec;
}

Referenced by Botan::TLS::Client_Hello_13::Client_Hello_13().

◆ empty()

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

inlineoverridevirtual

Returns: if we should encode this extension or not

Implements Botan::TLS::Extension.

Definition at line 337 of file tls_extensions.h.

337{ return m_groups.empty(); }

◆ groups()

const std::vector< Group_Params > & Botan::TLS::Supported_Groups::groups ( ) const

Definition at line 499 of file tls_extensions.cpp.

                                                              {
   return m_groups;
}

Referenced by Supported_Groups().

◆ is_implemented()

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

inlinevirtualinherited

Returns: true if this extension is known and implemented by Botan

Reimplemented in Botan::TLS::Unknown_Extension.

Definition at line 115 of file tls_extensions.h.

115{ return true; }

◆ serialize()

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

overridevirtual

Returns: serialized binary for the extension

Implements Botan::TLS::Extension.

Definition at line 523 of file tls_extensions.cpp.

                                                                      {
   std::vector<uint8_t> buf(2);
 
   for(auto g : m_groups) {
      const uint16_t id = g.wire_code();
 
      if(id > 0) {
         buf.push_back(get_byte<0>(id));
         buf.push_back(get_byte<1>(id));
      }
   }
 
   buf[0] = get_byte<0>(static_cast<uint16_t>(buf.size() - 2));
   buf[1] = get_byte<1>(static_cast<uint16_t>(buf.size() - 2));
 
   return buf;
}