Botan::ML_DSA_Symmetric_Primitives Class Reference

#include <ml_dsa_impl.h>

Inheritance diagram for Botan::ML_DSA_Symmetric_Primitives:

Public Member Functions
std::unique_ptr< DilithiumMessageHash >	get_message_hash (DilithiumHashedPublicKey tr) const override
std::unique_ptr< XOF >	H (StrongSpan< const DilithiumCommitmentHash > seed) const
DilithiumCommitmentHash	H (StrongSpan< const DilithiumMessageRepresentative > mu, StrongSpan< const DilithiumSerializedCommitment > w1) const
std::tuple< DilithiumSeedRho, DilithiumSeedRhoPrime, DilithiumSigningSeedK >	H (StrongSpan< const DilithiumSeedRandomness > seed) const
std::unique_ptr< XOF >	H (StrongSpan< const DilithiumSeedRho > seed, uint16_t nonce) const
std::unique_ptr< XOF >	H (StrongSpan< const DilithiumSeedRhoPrime > seed, uint16_t nonce) const
DilithiumHashedPublicKey	H (StrongSpan< const DilithiumSerializedPublicKey > pk) const
DilithiumSeedRhoPrime	H_maybe_randomized (StrongSpan< const DilithiumSigningSeedK > k, StrongSpan< const DilithiumMessageRepresentative > mu, std::optional< std::reference_wrapper< RandomNumberGenerator > > rng) const override
	ML_DSA_Symmetric_Primitives (const DilithiumConstants &mode)
std::optional< std::array< uint8_t, 2 > >	seed_expansion_domain_separator () const override
StrongSpan< const DilithiumCommitmentHash >	truncate_commitment_hash (StrongSpan< const DilithiumCommitmentHash > seed) const override

Static Public Member Functions
static std::unique_ptr< Dilithium_Symmetric_Primitives_Base >	create (const DilithiumConstants &mode)

Protected Member Functions
template<concepts::resizable_byte_buffer OutT, ranges::spanable_range... InTs>
OutT	H_256 (size_t outbytes, const InTs &... ins) const

Detailed Description

Definition at line 54 of file ml_dsa_impl.h.

Constructor & Destructor Documentation

ML_DSA_Symmetric_Primitives()

Botan::ML_DSA_Symmetric_Primitives::ML_DSA_Symmetric_Primitives ( const DilithiumConstants & mode )

inlineexplicit

Definition at line 64 of file ml_dsa_impl.h.

                                                                           :
            Dilithium_Symmetric_Primitives_Base(mode, std::make_unique<DilithiumShakeXOF>()),
            m_seed_expansion_domain_separator({mode.k(), mode.l()}) {}

References Botan::Dilithium_Symmetric_Primitives_Base::Dilithium_Symmetric_Primitives_Base(), Botan::DilithiumConstants::k(), and Botan::DilithiumConstants::l().

Member Function Documentation

create()

std::unique_ptr< Dilithium_Symmetric_Primitives_Base > Botan::Dilithium_Symmetric_Primitives_Base::create ( const DilithiumConstants & mode )

staticinherited

Definition at line 46 of file dilithium_symmetric_primitives.cpp.

                                   {
#if defined(BOTAN_HAS_DILITHIUM)
   if(mode.is_modern() && !mode.is_ml_dsa()) {
      return std::make_unique<Dilithium_Symmetric_Primitives>(mode);
   }
#endif
 
#if defined(BOTAN_HAS_DILITHIUM_AES)
   if(mode.is_aes()) {
      return std::make_unique<Dilithium_AES_Symmetric_Primitives>(mode);
   }
#endif
 
#if defined(BOTAN_HAS_ML_DSA)
   if(mode.is_ml_dsa()) {
      return std::make_unique<ML_DSA_Symmetric_Primitives>(mode);
   }
#endif
 
   throw Not_Implemented("requested ML-DSA/Dilithium mode is not implemented in this build");
}

References Botan::DilithiumConstants::is_aes(), Botan::DilithiumConstants::is_ml_dsa(), and Botan::DilithiumConstants::is_modern().

Referenced by Botan::DilithiumConstants::DilithiumConstants().

get_message_hash()

std::unique_ptr< DilithiumMessageHash > Botan::ML_DSA_Symmetric_Primitives::get_message_hash ( DilithiumHashedPublicKey tr ) const

inlineoverridevirtual

Reimplemented from Botan::Dilithium_Symmetric_Primitives_Base.

Definition at line 88 of file ml_dsa_impl.h.

                                                                                                       {
         return std::make_unique<ML_DSA_MessageHash>(std::move(tr));
      }

H() [1/6]

std::unique_ptr< XOF > Botan::Dilithium_Symmetric_Primitives_Base::H ( StrongSpan< const DilithiumCommitmentHash > seed ) const

inlineinherited

Definition at line 147 of file dilithium_symmetric_primitives.h.

                                                                                 {
         auto xof = XOF::create_or_throw("SHAKE-256");
         xof->update(truncate_commitment_hash(seed));
         return xof;
      }

References Botan::XOF::create_or_throw(), and truncate_commitment_hash().

H() [2/6]

DilithiumCommitmentHash Botan::Dilithium_Symmetric_Primitives_Base::H ( StrongSpan< const DilithiumMessageRepresentative > mu, StrongSpan< const DilithiumSerializedCommitment > w1 ) const

inlineinherited

Definition at line 142 of file dilithium_symmetric_primitives.h.

                                                                                          {
         return H_256<DilithiumCommitmentHash>(m_commitment_hash_length_bytes, mu, w1);
      }

References H_256().

H() [3/6]

std::tuple< DilithiumSeedRho, DilithiumSeedRhoPrime, DilithiumSigningSeedK > Botan::Dilithium_Symmetric_Primitives_Base::H ( StrongSpan< const DilithiumSeedRandomness > seed ) const

inlineinherited

Definition at line 124 of file dilithium_symmetric_primitives.h.

                                                               {
         auto xof = XOF::create_or_throw("SHAKE-256");
         xof->update(seed);
         if(auto domsep = seed_expansion_domain_separator()) {
            xof->update(domsep.value());
         }
 
         // Note: The order of invocations in an initializer list is not
         //       guaranteed by the C++ standard. Hence, we have to store the
         //       results in variables to ensure the correct order of execution.
         auto rho = xof->output<DilithiumSeedRho>(DilithiumConstants::SEED_RHO_BYTES);
         auto rhoprime = xof->output<DilithiumSeedRhoPrime>(DilithiumConstants::SEED_RHOPRIME_BYTES);
         auto k = xof->output<DilithiumSigningSeedK>(DilithiumConstants::SEED_SIGNING_KEY_BYTES);
 
         return {std::move(rho), std::move(rhoprime), std::move(k)};
      }

References Botan::XOF::create_or_throw(), Botan::rho(), seed_expansion_domain_separator(), Botan::DilithiumConstants::SEED_RHO_BYTES, Botan::DilithiumConstants::SEED_RHOPRIME_BYTES, and Botan::DilithiumConstants::SEED_SIGNING_KEY_BYTES.

H() [4/6]

std::unique_ptr< XOF > Botan::Dilithium_Symmetric_Primitives_Base::H ( StrongSpan< const DilithiumSeedRho > seed, uint16_t nonce ) const

inlineinherited

Definition at line 153 of file dilithium_symmetric_primitives.h.

                                                                                          {
         return m_xof_adapter->XOF128(seed, nonce);
      }

H() [5/6]

std::unique_ptr< XOF > Botan::Dilithium_Symmetric_Primitives_Base::H ( StrongSpan< const DilithiumSeedRhoPrime > seed, uint16_t nonce ) const

inlineinherited

Definition at line 157 of file dilithium_symmetric_primitives.h.

                                                                                               {
         return m_xof_adapter->XOF256(seed, nonce);
      }

H() [6/6]

DilithiumHashedPublicKey Botan::Dilithium_Symmetric_Primitives_Base::H ( StrongSpan< const DilithiumSerializedPublicKey > pk ) const

inlineinherited

Definition at line 120 of file dilithium_symmetric_primitives.h.

                                                                                          {
         return H_256<DilithiumHashedPublicKey>(m_public_key_hash_bytes, pk);
      }

References H_256().

Referenced by Botan::Dilithium_Algos::expand_mask(), and Botan::Dilithium_Algos::sample_in_ball().

H_256()

template<concepts::resizable_byte_buffer OutT, ranges::spanable_range... InTs>

OutT Botan::Dilithium_Symmetric_Primitives_Base::H_256 ( size_t outbytes, const InTs &... ins ) const

inlineprotectedinherited

Definition at line 178 of file dilithium_symmetric_primitives.h.

                                                            {
         auto xof = XOF::create_or_throw("SHAKE-256");
         (xof->update(ins), ...);
         return xof->output<OutT>(outbytes);
      }

References Botan::XOF::create_or_throw().

Referenced by H(), and H().

H_maybe_randomized()

DilithiumSeedRhoPrime Botan::ML_DSA_Symmetric_Primitives::H_maybe_randomized ( StrongSpan< const DilithiumSigningSeedK > k, StrongSpan< const DilithiumMessageRepresentative > mu, std::optional< std::reference_wrapper< RandomNumberGenerator > > rng ) const

inlineoverridevirtual

Computes the private random seed rho prime used for signing if a rng is given, the seed is randomized

Implements Botan::Dilithium_Symmetric_Primitives_Base.

Definition at line 68 of file ml_dsa_impl.h.

                                                                                      {
         // NIST FIPS 204, Algorithm 2 (ML-DSA.Sign), line 5-8:
         const auto rnd = [&] {
            DilithiumOptionalRandomness optional_randomness(DilithiumConstants::OPTIONAL_RANDOMNESS_BYTES);
            if(rng.has_value()) {
               rng->get().randomize(optional_randomness);
            }
            return optional_randomness;
         }();
         return H(k, rnd, mu);
      }

References Botan::DilithiumConstants::OPTIONAL_RANDOMNESS_BYTES.

seed_expansion_domain_separator()

std::optional< std::array< uint8_t, 2 > > Botan::ML_DSA_Symmetric_Primitives::seed_expansion_domain_separator ( ) const

inlineoverridevirtual

Creates the domain separator for the initial seed expansion. The return value may be std::nullopt meaning that no domain separation is required (for Dilithium).

Implements Botan::Dilithium_Symmetric_Primitives_Base.

Definition at line 92 of file ml_dsa_impl.h.

                                                                                         {
         return m_seed_expansion_domain_separator;
      }

truncate_commitment_hash()

StrongSpan< const DilithiumCommitmentHash > Botan::ML_DSA_Symmetric_Primitives::truncate_commitment_hash ( StrongSpan< const DilithiumCommitmentHash > seed ) const

inlineoverridevirtual

Implemented by the derived classes to truncate the commitment hash to the correct length. This is a customization point to enable support for the final ML-DSA standard.

Implements Botan::Dilithium_Symmetric_Primitives_Base.

Definition at line 83 of file ml_dsa_impl.h.

                                                                        {
         return seed;
      }

---

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

• src/lib/pubkey/dilithium/ml_dsa/ml_dsa_impl.h