Botan::EME Class Reference

#include <eme.h>

Inheritance diagram for Botan::EME:

Public Member Functions
secure_vector< uint8_t >	encode (const secure_vector< uint8_t > &in, size_t key_length, RandomNumberGenerator &rng) const
secure_vector< uint8_t >	encode (const uint8_t in[], size_t in_length, size_t key_length, RandomNumberGenerator &rng) const
virtual size_t	maximum_input_size (size_t keybits) const =0
virtual secure_vector< uint8_t >	pad (const uint8_t in[], size_t in_length, size_t key_length, RandomNumberGenerator &rng) const =0
virtual secure_vector< uint8_t >	unpad (uint8_t &valid_mask, const uint8_t in[], size_t in_len) const =0
virtual	~EME ()=default

Static Public Member Functions
static std::unique_ptr< EME >	create (std::string_view algo_spec)

Detailed Description

Encoding Method for Encryption

Definition at line 21 of file eme.h.

Constructor & Destructor Documentation

~EME()

virtual Botan::EME::~EME ( )

virtualdefault

Member Function Documentation

create()

std::unique_ptr< EME > Botan::EME::create ( std::string_view algo_spec )

static

Factory method for EME (message-encoding methods for encryption) objects

Parameters

algo_spec

the name of the EME to create

Returns

pointer to newly allocated object of that type

Definition at line 28 of file eme.cpp.

                                                       {
#if defined(BOTAN_HAS_EME_RAW)
   if(algo_spec == "Raw") {
      return std::make_unique<EME_Raw>();
   }
#endif
 
#if defined(BOTAN_HAS_EME_PKCS1)
   if(algo_spec == "PKCS1v15" || algo_spec == "EME-PKCS1-v1_5") {
      return std::make_unique<EME_PKCS1v15>();
   }
#endif
 
#if defined(BOTAN_HAS_EME_OAEP)
   SCAN_Name req(algo_spec);
 
   if(req.algo_name() == "OAEP" || req.algo_name() == "EME-OAEP" || req.algo_name() == "EME1") {
      if(req.arg_count() == 1 || ((req.arg_count() == 2 || req.arg_count() == 3) && req.arg(1) == "MGF1")) {
         if(auto hash = HashFunction::create(req.arg(0))) {
            return std::make_unique<OAEP>(std::move(hash), req.arg(2, ""));
         }
      } else if(req.arg_count() == 2 || req.arg_count() == 3) {
         auto mgf_params = parse_algorithm_name(req.arg(1));
 
         if(mgf_params.size() == 2 && mgf_params[0] == "MGF1") {
            auto hash = HashFunction::create(req.arg(0));
            auto mgf1_hash = HashFunction::create(mgf_params[1]);
 
            if(hash && mgf1_hash) {
               return std::make_unique<OAEP>(std::move(hash), std::move(mgf1_hash), req.arg(2, ""));
            }
         }
      }
   }
#endif
 
   throw Algorithm_Not_Found(algo_spec);
}

References Botan::SCAN_Name::algo_name(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_count(), Botan::HashFunction::create(), and Botan::parse_algorithm_name().

encode() [1/2]

secure_vector< uint8_t > Botan::EME::encode	(	const secure_vector< uint8_t > &	in,
		size_t	key_length,
		RandomNumberGenerator &	rng ) const

Encode an input

Parameters

in	the plaintext
key_length	length of the key in bits
rng	a random number generator

Returns

encoded plaintext

Definition at line 80 of file eme.cpp.

                                                                     {
   return pad(msg.data(), msg.size(), key_bits, rng);
}

References pad().

encode() [2/2]

secure_vector< uint8_t > Botan::EME::encode	(	const uint8_t	in[],
		size_t	in_length,
		size_t	key_length,
		RandomNumberGenerator &	rng ) const

Encode an input

Parameters

in	the plaintext
in_length	length of plaintext in bytes
key_length	length of the key in bits
rng	a random number generator

Returns

encoded plaintext

Definition at line 70 of file eme.cpp.

                                                                     {
   return pad(msg, msg_len, key_bits, rng);
}

References pad().

maximum_input_size()

virtual size_t Botan::EME::maximum_input_size ( size_t keybits ) const

pure virtual

Return the maximum input size in bytes we can support

Parameters

keybits

the size of the key in bits

Returns

upper bound of input in bytes

Implemented in Botan::EME_Raw, Botan::OAEP, and Botan::EME_PKCS1v15.

pad()

virtual secure_vector< uint8_t > Botan::EME::pad ( const uint8_t in[], size_t in_length, size_t key_length, RandomNumberGenerator & rng ) const

pure virtual

Encode an input

Parameters

in	the plaintext
in_length	length of plaintext in bytes
key_length	length of the key in bits
rng	a random number generator

Returns

encoded plaintext

Implemented in Botan::EME_PKCS1v15.

Referenced by encode(), and encode().

unpad()

virtual secure_vector< uint8_t > Botan::EME::unpad ( uint8_t & valid_mask, const uint8_t in[], size_t in_len ) const

pure virtual

Decode an input

Parameters

valid_mask	written to specifies if output is valid
in	the encoded plaintext
in_len	length of encoded plaintext in bytes

Returns

bytes of out[] written to along with validity mask (0xFF if valid, else 0x00)

Implemented in Botan::EME_PKCS1v15.

---

The documentation for this class was generated from the following files:

• src/lib/pk_pad/eme.h
• src/lib/pk_pad/eme.cpp