Botan::Classic_McEliece_Encryptor Class Reference

#include <cmce_encaps.h>

Inheritance diagram for Botan::Classic_McEliece_Encryptor:

Public Member Functions
	Classic_McEliece_Encryptor (std::shared_ptr< Classic_McEliece_PublicKeyInternal > key, std::string_view kdf)
size_t	encapsulated_key_length () const override
void	kem_encrypt (std::span< uint8_t > out_encapsulated_key, std::span< uint8_t > out_shared_key, RandomNumberGenerator &rng, size_t desired_shared_key_len, std::span< const uint8_t > salt) final
void	raw_kem_encrypt (std::span< uint8_t > out_encapsulated_key, std::span< uint8_t > out_shared_key, RandomNumberGenerator &rng) override
size_t	raw_kem_shared_key_length () const override
size_t	shared_key_length (size_t desired_shared_key_len) const final

Detailed Description

Classic McEliece Encapsulation Operation

Definition at line 28 of file cmce_encaps.h.

Constructor & Destructor Documentation

Classic_McEliece_Encryptor()

Botan::Classic_McEliece_Encryptor::Classic_McEliece_Encryptor ( std::shared_ptr< Classic_McEliece_PublicKeyInternal > key, std::string_view kdf )

inline

Definition at line 30 of file cmce_encaps.h.

                                                                                                            :
            KEM_Encryption_with_KDF(kdf), m_key(std::move(key)) {}

References Botan::PK_Ops::KEM_Encryption_with_KDF::KEM_Encryption_with_KDF().

Member Function Documentation

encapsulated_key_length()

size_t Botan::Classic_McEliece_Encryptor::encapsulated_key_length ( ) const

inlineoverridevirtual

Implements Botan::PK_Ops::KEM_Encryption.

Definition at line 35 of file cmce_encaps.h.

{ return m_key->params().ciphertext_size(); }

kem_encrypt()

void Botan::PK_Ops::KEM_Encryption_with_KDF::kem_encrypt ( std::span< uint8_t > out_encapsulated_key, std::span< uint8_t > out_shared_key, RandomNumberGenerator & rng, size_t desired_shared_key_len, std::span< const uint8_t > salt )

finalvirtualinherited

Implements Botan::PK_Ops::KEM_Encryption.

Definition at line 210 of file pk_ops.cpp.

                                                                               {
   BOTAN_ARG_CHECK(salt.empty() || m_kdf, "PK_KEM_Encryptor::encrypt requires a KDF to use a salt");
   BOTAN_ASSERT_NOMSG(out_encapsulated_key.size() == encapsulated_key_length());
 
   if(m_kdf) {
      BOTAN_ASSERT_EQUAL(
         out_shared_key.size(), desired_shared_key_len, "KDF output length and shared key length match");
 
      secure_vector<uint8_t> raw_shared(raw_kem_shared_key_length());
      this->raw_kem_encrypt(out_encapsulated_key, raw_shared, rng);
      m_kdf->derive_key(out_shared_key, raw_shared, salt, {});
   } else {
      BOTAN_ASSERT_EQUAL(out_shared_key.size(), raw_kem_shared_key_length(), "Shared key has raw KEM output length");
      this->raw_kem_encrypt(out_encapsulated_key, out_shared_key, rng);
   }
}

References BOTAN_ARG_CHECK, BOTAN_ASSERT_EQUAL, BOTAN_ASSERT_NOMSG, Botan::PK_Ops::KEM_Encryption::encapsulated_key_length(), raw_kem_encrypt(), and raw_kem_shared_key_length().

raw_kem_encrypt()

void Botan::Classic_McEliece_Encryptor::raw_kem_encrypt ( std::span< uint8_t > out_encapsulated_key, std::span< uint8_t > out_shared_key, RandomNumberGenerator & rng )

overridevirtual

Implements Botan::PK_Ops::KEM_Encryption_with_KDF.

Definition at line 87 of file cmce_encaps.cpp.

                                                                             {
   BOTAN_ARG_CHECK(out_encapsulated_key.size() == m_key->params().ciphertext_size(),
                   "Incorrect encapsulated key output length");
   BOTAN_ARG_CHECK(out_shared_key.size() == m_key->params().hash_out_bytes(), "Incorrect shared key output length");
 
   const auto& params = m_key->params();
 
   // Call fixed_weight until it is successful to
   // create a random error vector e of weight tau
   const CmceErrorVector e = [&] {
      // Emergency abort in case unexpected logical error to prevent endless loops
      //   Success probability: >24% per attempt (25% that elements are distinct * 96% enough elements are in range)
      //   => 647 attempts for 2^(-256) fail probability
      constexpr size_t MAX_ATTEMPTS = 647;
      for(size_t attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
         if(auto maybe_e = fixed_weight_vector_gen(params, rng)) {
            return maybe_e.value();
         }
      }
      throw Internal_Error("Cannot created fixed weight vector. Is your RNG broken?");
   }();
 
   auto hash_func = params.hash_func();
 
   BufferStuffer big_c_stuf(out_encapsulated_key);
   const auto e_bytes = e.get().to_bytes();
   // Compute and store ciphertext C/C_0 from spec
   const auto big_c_0 = encode(params, e, m_key->matrix());
   big_c_0.to_bytes(big_c_stuf.next(ceil_tobytes(big_c_0.size())));
   if(params.is_pc()) {
      // Compute and store ciphertext C_1 from spec
      hash_func->update(0x02);
      hash_func->update(e_bytes);
      hash_func->final(big_c_stuf.next(hash_func->output_length()));
   }
   BOTAN_ASSERT_NOMSG(big_c_stuf.full());
 
   // Compute K = Hash(1,e,C) from spec
   hash_func->update(0x01);
   hash_func->update(e_bytes);
   hash_func->update(out_encapsulated_key);
   hash_func->final(out_shared_key);
   CT::unpoison_all(out_encapsulated_key, out_shared_key);
}

References BOTAN_ARG_CHECK, BOTAN_ASSERT_NOMSG, Botan::ceil_tobytes(), Botan::BufferStuffer::full(), Botan::detail::Strong_Base< T >::get(), Botan::BufferStuffer::next(), Botan::bitvector_base< AllocatorT >::to_bytes(), and Botan::CT::unpoison_all().

raw_kem_shared_key_length()

size_t Botan::Classic_McEliece_Encryptor::raw_kem_shared_key_length ( ) const

inlineoverridevirtual

Implements Botan::PK_Ops::KEM_Encryption_with_KDF.

Definition at line 33 of file cmce_encaps.h.

{ return m_key->params().hash_out_bytes(); }

shared_key_length()

size_t Botan::PK_Ops::KEM_Encryption_with_KDF::shared_key_length ( size_t desired_shared_key_len ) const

finalvirtualinherited

Implements Botan::PK_Ops::KEM_Encryption.

Definition at line 202 of file pk_ops.cpp.

                                                                                           {
   if(m_kdf) {
      return desired_shared_key_len;
   } else {
      return this->raw_kem_shared_key_length();
   }
}

References raw_kem_shared_key_length().

---

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

• src/lib/pubkey/classic_mceliece/cmce_encaps.h
• src/lib/pubkey/classic_mceliece/cmce_encaps.cpp