Botan::Classic_McEliece_Decryptor Class Reference

#include <cmce_decaps.h>

Inheritance diagram for Botan::Classic_McEliece_Decryptor:

Public Member Functions
	Classic_McEliece_Decryptor (std::shared_ptr< Classic_McEliece_PrivateKeyInternal > key, std::string_view kdf)
	Constructs a Classic_McEliece_Decryptor object with the given private key.
size_t	encapsulated_key_length () const override
void	kem_decrypt (std::span< uint8_t > out_shared_key, std::span< const uint8_t > encapsulated_key, size_t desired_shared_key_len, std::span< const uint8_t > salt) final
void	raw_kem_decrypt (std::span< uint8_t > out_shared_key, std::span< const uint8_t > encapsulated_key) 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 Decapsulation Operation

Definition at line 27 of file cmce_decaps.h.

Constructor & Destructor Documentation

Classic_McEliece_Decryptor()

Botan::Classic_McEliece_Decryptor::Classic_McEliece_Decryptor ( std::shared_ptr< Classic_McEliece_PrivateKeyInternal > key, std::string_view kdf )

inline

Constructs a Classic_McEliece_Decryptor object with the given private key.

Parameters

key	The private key used for decryption.

Definition at line 33 of file cmce_decaps.h.

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

Member Function Documentation

encapsulated_key_length()

size_t Botan::Classic_McEliece_Decryptor::encapsulated_key_length ( ) const

inlineoverridevirtual

Implements Botan::PK_Ops::KEM_Decryption.

Definition at line 38 of file cmce_decaps.h.

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

kem_decrypt()

void Botan::PK_Ops::KEM_Decryption_with_KDF::kem_decrypt ( std::span< uint8_t > out_shared_key, std::span< const uint8_t > encapsulated_key, size_t desired_shared_key_len, std::span< const uint8_t > salt )

finalvirtualinherited

Implements Botan::PK_Ops::KEM_Decryption.

Definition at line 243 of file pk_ops.cpp.

                                                                               {
   BOTAN_ARG_CHECK(salt.empty() || m_kdf, "PK_KEM_Decryptor::decrypt requires a KDF to use a salt");
 
   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_decrypt(raw_shared, encapsulated_key);
      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_decrypt(out_shared_key, encapsulated_key);
   }
}

References BOTAN_ARG_CHECK, and BOTAN_ASSERT_EQUAL.

raw_kem_decrypt()

void Botan::Classic_McEliece_Decryptor::raw_kem_decrypt ( std::span< uint8_t > out_shared_key, std::span< const uint8_t > encapsulated_key )

overridevirtual

Implements Botan::PK_Ops::KEM_Decryption_with_KDF.

Definition at line 125 of file cmce_decaps.cpp.

                                                                                          {
   BOTAN_ARG_CHECK(out_shared_key.size() == m_key->params().hash_out_bytes(), "Invalid shared key output size");
   BOTAN_ARG_CHECK(encapsulated_key.size() == m_key->params().ciphertext_size(), "Invalid ciphertext size");
 
   auto scope = CT::scoped_poison(*m_key);
 
   auto [ct, c1] = [&]() -> std::pair<CmceCodeWord, std::span<const uint8_t>> {
      if(m_key->params().is_pc()) {
         BufferSlicer encaps_key_slicer(encapsulated_key);
         auto c0_ret = encaps_key_slicer.take(m_key->params().encode_out_size());
         auto c1_ret = encaps_key_slicer.take(m_key->params().hash_out_bytes());
         BOTAN_ASSERT_NOMSG(encaps_key_slicer.empty());
         return {CmceCodeWord(secure_bitvector(c0_ret, m_key->params().m() * m_key->params().t())), c1_ret};
      } else {
         return {CmceCodeWord(secure_bitvector(encapsulated_key, m_key->params().m() * m_key->params().t())), {}};
      }
   }();
 
   auto [decode_success_mask, maybe_e] = decode(ct);
 
   secure_vector<uint8_t> e_bytes(m_key->s().size());
   decode_success_mask.select_n(e_bytes.data(), maybe_e.get().to_bytes().data(), m_key->s().data(), m_key->s().size());
   uint8_t b = decode_success_mask.select(1, 0);
 
   auto hash_func = m_key->params().hash_func();
 
   if(m_key->params().is_pc()) {
      hash_func->update(0x02);
      hash_func->update(e_bytes);
      const auto c1_p = hash_func->final_stdvec();
      const CT::Mask<uint8_t> eq_mask = CT::is_equal(c1.data(), c1_p.data(), c1.size());
      eq_mask.select_n(e_bytes.data(), e_bytes.data(), m_key->s().data(), m_key->s().size());
      b = eq_mask.select(b, 0);
   }
 
   hash_func->update(b);
   hash_func->update(e_bytes);
   hash_func->update(encapsulated_key);
   hash_func->final(out_shared_key);
   CT::unpoison(out_shared_key);
}

References Botan::b, BOTAN_ARG_CHECK, BOTAN_ASSERT_NOMSG, Botan::BufferSlicer::empty(), Botan::CT::is_equal(), Botan::CT::scoped_poison(), Botan::CT::Mask< T >::select(), Botan::CT::Mask< T >::select_n(), Botan::BufferSlicer::take(), and Botan::CT::unpoison().

raw_kem_shared_key_length()

size_t Botan::Classic_McEliece_Decryptor::raw_kem_shared_key_length ( ) const

inlineoverridevirtual

Implements Botan::PK_Ops::KEM_Decryption_with_KDF.

Definition at line 36 of file cmce_decaps.h.

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

shared_key_length()

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

finalvirtualinherited

Implements Botan::PK_Ops::KEM_Decryption.

Definition at line 235 of file pk_ops.cpp.

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

---

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

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