16#include <botan/dilithium.h>
18#include <botan/exceptn.h>
19#include <botan/pk_options_readers.h>
21#include <botan/internal/dilithium_algos.h>
22#include <botan/internal/dilithium_keys.h>
23#include <botan/internal/dilithium_symmetric_primitives.h>
24#include <botan/internal/dilithium_types.h>
25#include <botan/internal/fmt.h>
26#include <botan/internal/keypair.h>
27#include <botan/internal/pk_ops_impl.h>
28#include <botan/internal/pk_options_impl.h>
29#include <botan/internal/stl_util.h>
37 if(str ==
"Dilithium-4x4-r3") {
40 if(str ==
"Dilithium-4x4-AES-r3") {
43 if(str ==
"Dilithium-6x5-r3") {
46 if(str ==
"Dilithium-6x5-AES-r3") {
49 if(str ==
"Dilithium-8x7-r3") {
52 if(str ==
"Dilithium-8x7-AES-r3") {
55 if(str ==
"ML-DSA-4x4") {
58 if(str ==
"ML-DSA-6x5") {
61 if(str ==
"ML-DSA-8x7") {
69 if(
const auto name = oid.registered_name()) {
70 return dilithium_mode_from_string(*
name);
89 return "Dilithium-4x4-r3";
91 return "Dilithium-4x4-AES-r3";
93 return "Dilithium-6x5-r3";
95 return "Dilithium-6x5-AES-r3";
97 return "Dilithium-8x7-r3";
99 return "Dilithium-8x7-AES-r3";
124#if defined(BOTAN_HAS_DILITHIUM_AES)
129#if defined(BOTAN_HAS_DILITHIUM)
134#if defined(BOTAN_HAS_ML_DSA)
153 "Dilithium cannot support a salt while also being deterministic");
155 const size_t randomness_bytes =
158 if(options.
salt_size().value() != randomness_bytes) {
168 if(
const auto& ctx = options.
context()) {
170 BOTAN_ARG_CHECK(ctx->size() <= 255,
"ML-DSA context must not exceed 255 bytes");
182 m_keypair(std::move(keypair)),
188 m_randomized(!options.using_deterministic_signature()),
189 m_h(m_keypair.second->mode().symmetric_primitives().get_message_hash(
190 m_keypair.first->tr(), options.context().value_or(std::vector<uint8_t>{}))),
191 m_s1(
ntt(m_keypair.second->s1().clone())),
192 m_s2(
ntt(m_keypair.second->s2().clone())),
193 m_t0(
ntt(m_keypair.second->t0().clone())),
195 validate_dilithium_options(options, m_keypair.second->mode().mode());
198 void update(std::span<const uint8_t> input)
override { m_h->update(input); }
211 std::vector<uint8_t> sign(RandomNumberGenerator& rng)
override {
214 const auto mu = m_h->final();
215 const auto& mode = m_keypair.second->
mode();
216 const auto& sympri = mode.symmetric_primitives();
218 const auto rhoprime = sympri.H_maybe_randomized(m_keypair.second->signing_seed(), mu, maybe(rng));
224 auto w_ntt = m_A *
ntt(y.clone());
227 w.conditional_add_q();
263 w0.conditional_add_q();
264 const auto& w0cs2ct0 = w0;
275 throw Internal_Error(
"ML-DSA/Dilithium signature loop did not terminate");
278 size_t signature_length()
const override {
return m_keypair.second->mode().signature_bytes(); }
281 return AlgorithmIdentifier(m_keypair.second->mode().mode().object_identifier(),
285 std::string
hash_function()
const override {
return m_h->name(); }
288 std::optional<std::reference_wrapper<RandomNumberGenerator>> maybe(RandomNumberGenerator& rng)
const {
299 std::unique_ptr<DilithiumMessageHash> m_h;
309 Dilithium_Verification_Operation(std::shared_ptr<const Dilithium_PublicKeyInternal> pubkey,
310 const PK_Signature_Options_Reader& options) :
311 m_pub_key(std::move(pubkey)),
312 m_A(Dilithium_Algos::
expand_A(m_pub_key->
rho(), m_pub_key->mode())),
313 m_t1_ntt_shifted(
ntt(m_pub_key->t1() << DilithiumConstants::D)),
314 m_h(m_pub_key->mode().symmetric_primitives().get_message_hash(
315 m_pub_key->tr(), options.context().value_or(std::vector<uint8_t>{}))) {}
317 void update(std::span<const uint8_t> input)
override { m_h->update(input); }
329 bool is_valid_signature(std::span<const uint8_t> sig)
override {
330 const auto& mode = m_pub_key->
mode();
331 const auto& sympri = mode.symmetric_primitives();
332 const StrongSpan<const DilithiumSerializedSignature> sig_bytes(sig);
334 const auto mu = m_h->final();
336 if(sig_bytes.size() != mode.signature_bytes()) {
341 if(!signature.has_value()) {
344 auto [ch, z, h] = std::move(signature.value());
347 if(!mode.
is_ml_dsa() && h.hamming_weight() > mode.omega()) {
356 auto w_approx = m_A *
ntt(std::move(z));
357 w_approx -= c_hat * m_t1_ntt_shifted;
360 w1.conditional_add_q();
366 return std::equal(ch.begin(), ch.end(), chprime.begin());
369 std::string
hash_function()
const override {
return m_h->name(); }
372 std::shared_ptr<const Dilithium_PublicKeyInternal> m_pub_key;
375 std::unique_ptr<DilithiumMessageHash> m_h;
382 throw Decoding_Error(
"Unexpected parameters for ML-DSA/Dilithium public key");
402 return (
m_public->mode().is_ml_dsa()) ? std::string(
"ML-DSA") :
m_public->mode().mode().to_string();
410 return m_public->mode().mode().object_identifier();
414 return m_public->mode().canonical_parameter_set_identifier();
442 return std::make_unique<Dilithium_PrivateKey>(rng,
m_public->mode().mode());
447 validate_dilithium_options(options,
m_public->mode().mode());
451 return std::make_unique<Dilithium_Verification_Operation>(
m_public, options);
456 if(provider.empty() || provider ==
"base") {
458 throw Decoding_Error(
"Unexpected AlgorithmIdentifier for Dilithium X.509 signature");
460 return std::make_unique<Dilithium_Verification_Operation>(
488 throw Decoding_Error(
"Unexpected parameters for ML-DSA/Dilithium private key");
496 m_public = std::move(decoded.keypair.first);
497 m_private = std::move(decoded.keypair.second);
498 m_private_key_format = decoded.format;
502 return m_private_key_format;
509 throw Encoding_Error(
"Dilithium round 3 private keys only support the expanded format");
511 const auto& seed = m_private->seed();
512 if(!seed.has_value()) {
513 throw Encoding_Error(
"ML-DSA private key does not contain the seed, cannot encode it in the seed format");
521 "there is no raw encoding of an ML-DSA private key containing both seed and expanded key");
527 return m_private->mode().keypair_codec().encode_keypair({
m_public, m_private}, format);
531 return m_private->mode().is_ml_dsa();
535 return !m_private->mode().is_ml_dsa();
560 return std::make_unique<Dilithium_PublicKey>(*
this);
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_ARG_CHECK(expr, msg)
#define BOTAN_ASSERT_UNREACHABLE()
bool parameters_are_empty() const
static constexpr size_t SEED_RANDOMNESS_BYTES
DilithiumMode mode() const
static constexpr size_t OPTIONAL_RANDOMNESS_BYTES
Dilithium_Keypair_Codec & keypair_codec() const
static constexpr size_t SEED_RHOPRIME_BYTES
static constexpr uint16_t SIGNING_LOOP_BOUND
OID object_identifier() const
std::string to_string() const
bool is_dilithium_round3() const
bool is_available() const
virtual DilithiumDecodedKeypair decode_keypair(std::span< const uint8_t > private_key, DilithiumConstants mode) const =0
MlPrivateKeyFormat private_key_format() const override
Dilithium_PrivateKey(RandomNumberGenerator &rng, DilithiumMode mode)
secure_vector< uint8_t > formatted_raw_private_key_bits(MlPrivateKeyFormat format) const override
bool check_key(RandomNumberGenerator &rng, bool strong) const override
bool is_dilithium_round3() const
std::unique_ptr< Public_Key > public_key() const override
std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &options) const override
secure_vector< uint8_t > formatted_private_key_bits(MlPrivateKeyFormat format) const override
static std::shared_ptr< Dilithium_PublicKeyInternal > decode(DilithiumConstants mode, StrongSpan< const DilithiumSerializedPublicKey > raw_pk)
AlgorithmIdentifier algorithm_identifier() const override
std::vector< uint8_t > public_key_bits() const override
OID object_identifier() const override
std::unique_ptr< PK_Ops::Verification > _create_verification_op(const PK_Signature_Options_Reader &options) const override
Dilithium_PublicKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > pk)
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
std::unique_ptr< PK_Ops::Verification > create_x509_verification_op(const AlgorithmIdentifier &signature_algorithm, std::string_view provider) const override
size_t key_length() const override
std::string algo_name() const override
size_t estimated_strength() const override
Dilithium_PublicKey()=default
std::shared_ptr< const Dilithium_PublicKeyInternal > m_public
std::vector< uint8_t > raw_public_key_bits() const override
bool check_key(RandomNumberGenerator &rng, bool strong) const override
static OID from_string(std::string_view str)
virtual AlgorithmIdentifier algorithm_identifier() const
virtual size_t signature_length() const =0
virtual std::string hash_function() const =0
virtual std::string hash_function() const =0
static PK_Signature_Options_Reader for_verification(const PK_Signature_Options &options)
const std::optional< std::vector< uint8_t > > & context() const
bool using_salt_size() const
bool using_deterministic_signature() const
const std::optional< size_t > & salt_size() const
void random_vec(std::span< uint8_t > v)
constexpr decltype(auto) driveby_unpoison(T &&v)
constexpr auto scoped_poison(const Ts &... xs)
constexpr void unpoison(const T *p, size_t n)
constexpr void poison(const T *p, size_t n)
DilithiumInternalKeypair expand_keypair(DilithiumSeedRandomness xi, DilithiumConstants mode)
DilithiumSerializedSignature encode_signature(StrongSpan< const DilithiumCommitmentHash > c, const DilithiumPolyVec &response, const DilithiumPolyVec &hint, const DilithiumConstants &mode)
DilithiumSerializedPrivateKey encode_keypair(const DilithiumInternalKeypair &keypair)
DilithiumSerializedCommitment encode_commitment(const DilithiumPolyVec &w1, const DilithiumConstants &mode)
bool infinity_norm_within_bound(const DilithiumPolyVec &vec, size_t bound)
std::pair< DilithiumPolyVec, DilithiumPolyVec > decompose(const DilithiumPolyVec &vec, const DilithiumConstants &mode)
DilithiumPolyVec expand_mask(StrongSpan< const DilithiumSeedRhoPrime > rhoprime, uint16_t nonce, const DilithiumConstants &mode)
DilithiumPolyMatNTT expand_A(StrongSpan< const DilithiumSeedRho > rho, const DilithiumConstants &mode)
void use_hint(DilithiumPolyVec &vec, const DilithiumPolyVec &hints, const DilithiumConstants &mode)
std::optional< std::tuple< DilithiumCommitmentHash, DilithiumPolyVec, DilithiumPolyVec > > decode_signature(StrongSpan< const DilithiumSerializedSignature > sig, const DilithiumConstants &mode)
DilithiumPolyVec make_hint(const DilithiumPolyVec &z, const DilithiumPolyVec &r, const DilithiumConstants &mode)
DilithiumPoly sample_in_ball(StrongSpan< const DilithiumCommitmentHash > seed, const DilithiumConstants &mode)
bool signature_consistency_check(RandomNumberGenerator &rng, const Private_Key &private_key, const Public_Key &public_key, std::string_view padding)
BOTAN_FN_ISA_AVX2 void inverse_ntt(std::span< int16_t, 256 > p)
BOTAN_FN_ISA_AVX2 void ntt(std::span< int16_t, 256 > p)
Botan::CRYSTALS::PolynomialVector< DilithiumPolyTraits, Botan::CRYSTALS::Domain::NTT > DilithiumPolyVecNTT
std::string fmt(std::string_view format, const T &... args)
Strong< secure_vector< uint8_t >, struct DilithiumSeedRandomness_ > DilithiumSeedRandomness
Principal seed used to generate Dilithium key pairs.
auto to_underlying(T e) noexcept
BOTAN_FORCE_INLINE constexpr T rho(T x)
void require_software_provider(const OptionsT &options, std::string_view algo_name)
std::vector< T, secure_allocator< T > > secure_vector
Botan::CRYSTALS::PolynomialMatrix< DilithiumPolyTraits > DilithiumPolyMatNTT
std::pair< std::shared_ptr< const Dilithium_PublicKeyInternal >, std::shared_ptr< const Dilithium_PrivateKeyInternal > > DilithiumInternalKeypair
Internal representation of a Dilithium key pair.