#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 (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 247 of file tls_extensions.h.

Constructor & Destructor Documentation

◆ Supported_Groups() [1/2]

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

explicit

Definition at line 621 of file tls_extensions.cpp.

621: m_groups(std::move(groups)) {}

Botan::TLS::Supported_Groups::groups

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

Definition tls_extensions.cpp:623

References groups().

◆ Supported_Groups() [2/2]

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

Definition at line 667 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");
   }
 
   // RFC 8446 4.2.7: NamedGroup named_group_list<2..2^16-1>;
   if(len == 0) {
      throw Decoding_Error("Empty supported groups list");
   }
 
   if(len % 2 == 1) {
      throw Decoding_Error("Supported groups list of strange size");
   }
 
   const size_t elems = len / 2;
 
   std::unordered_set<uint16_t> seen;
   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(seen.insert(group.wire_code()).second) {
         m_groups.push_back(group);
      }
   }
}

References Botan::TLS::TLS_Data_Reader::get_uint16_t().

Member Function Documentation

◆ dh_groups()

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

Definition at line 637 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 627 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

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 267 of file tls_extensions.h.

267{ return m_groups.empty(); }

◆ groups()

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

Definition at line 623 of file tls_extensions.cpp.

                                                              {
   return m_groups;
}

Referenced by Supported_Groups().

◆ 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; }

◆ serialize()

std::vector< uint8_t > Botan::TLS::Supported_Groups::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 647 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));
      }
   }
 
   // RFC 8446 4.2.7: NamedGroup named_group_list<2..2^16-1>;
   BOTAN_ASSERT_NOMSG(buf.size() - 2 <= 0xFFFF);
   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;
}