11#include <botan/exceptn.h>
12#include <botan/pk_options_readers.h>
13#include <botan/internal/buffer_stuffer.h>
14#include <botan/internal/ct_utils.h>
15#include <botan/internal/divide.h>
16#include <botan/internal/dl_scheme.h>
17#include <botan/internal/keypair.h>
18#include <botan/internal/pk_ops_impl.h>
19#include <botan/internal/pk_options_impl.h>
21#if defined(BOTAN_HAS_RFC6979_GENERATOR)
22 #include <botan/internal/rfc6979.h>
29void check_dsa_group(
const DL_Group& group) {
34 const size_t q_bits = group.q_bits();
35 const size_t p_bits = group.p_bits();
40 if(q_bits < 160 || q_bits > 256) {
43 if(p_bits < 512 || p_bits > 3072) {
51 return m_public_key->group().q_bytes();
55 return m_public_key->estimated_strength();
59 return m_public_key->p_bits();
63 return m_public_key->get_int_field(
algo_name(), field);
71 return m_public_key->public_key_as_bytes();
75 return m_public_key->DER_encode();
79 return m_public_key->check_key(rng, strong);
83 return std::make_unique<DSA_PrivateKey>(rng, m_public_key->group());
89 check_dsa_group(m_public_key->group());
93 m_public_key = std::make_shared<DL_PublicKey>(group, y);
95 check_dsa_group(m_public_key->group());
99 check_dsa_group(group);
101 m_private_key = std::make_shared<DL_PrivateKey>(group, rng);
102 m_public_key = m_private_key->public_key();
106 check_dsa_group(group);
108 m_private_key = std::make_shared<DL_PrivateKey>(group, x);
109 m_public_key = m_private_key->public_key();
114 m_public_key = m_private_key->public_key();
116 check_dsa_group(m_private_key->group());
120 if(!m_private_key->check_key(rng, strong)) {
132 return m_private_key->DER_encode();
136 return m_private_key->raw_private_key_bits();
140 return m_private_key->get_int_field(
algo_name(), field);
145 return std::unique_ptr<DSA_PublicKey>(
new DSA_PublicKey(m_public_key));
155 DSA_Signature_Operation(
const std::shared_ptr<const DL_PrivateKey>& key,
158 PK_Ops::Signature_with_Hash(options), m_key(key), m_deterministic(options.using_deterministic_signature()) {
159#if !defined(BOTAN_HAS_RFC6979_GENERATOR)
160 if(m_deterministic) {
161 throw Not_Implemented(
"Deterministic DSA signatures require RFC 6979 support");
166 m_b_inv = m_key->group().inverse_mod_q(m_b);
170 size_t signature_length()
const override {
return 2 * m_key->group().q_bytes(); }
172 std::vector<uint8_t> raw_sign(std::span<const uint8_t> msg, RandomNumberGenerator& rng)
override;
174 AlgorithmIdentifier algorithm_identifier()
const override;
177 std::shared_ptr<const DL_PrivateKey> m_key;
178 bool m_deterministic;
183 const std::string full_name =
"DSA/" + hash_function();
184 const OID oid = OID::from_string(full_name);
185 return AlgorithmIdentifier(oid, AlgorithmIdentifier::USE_EMPTY_PARAM);
188std::vector<uint8_t> DSA_Signature_Operation::raw_sign(std::span<const uint8_t> msg, RandomNumberGenerator& rng) {
189 const DL_Group& group = m_key->group();
190 const BigInt& q = group.get_q();
192 BigInt m = BigInt::from_bytes_with_max_bits(msg.data(), msg.size(), group.q_bits());
198 const auto scope = CT::scoped_poison(m_key->private_key(), m_b, m_b_inv);
200#if defined(BOTAN_HAS_RFC6979_GENERATOR)
201 const BigInt k = m_deterministic ?
generate_rfc6979_nonce(m_key->private_key(), q, m, this->rfc6979_hash_function())
202 : BigInt::random_integer(rng, 1, q);
204 const BigInt k = BigInt::random_integer(rng, 1, q);
208 const BigInt k_inv = group.multiply_mod_q(group.inverse_mod_q(group.mod_q(m_b * k)), m_b);
219 const BigInt r =
ct_modulo(group.power_g_p(k, group.q_bits()), group.get_q());
224 m_b = group.square_mod_q(m_b);
225 m_b_inv = group.square_mod_q(m_b_inv);
227 m = group.multiply_mod_q(m_b, m);
228 const BigInt xr = group.multiply_mod_q(m_b, m_key->private_key(), r);
230 const BigInt s = group.multiply_mod_q(m_b_inv, k_inv, group.mod_q(xr + m));
232 CT::unpoison_all(r, s);
235 if(r.is_zero() || s.is_zero()) {
239 const size_t q_bytes = q.bytes();
240 std::vector<uint8_t> sig(2 * q_bytes);
241 BufferStuffer stuffer(sig);
242 r.serialize_to(stuffer.next(q_bytes));
243 s.serialize_to(stuffer.next(q_bytes));
250class DSA_Verification_Operation final :
public PK_Ops::Verification_with_Hash {
252 DSA_Verification_Operation(
const std::shared_ptr<const DL_PublicKey>& key,
253 const PK_Signature_Options_Reader& options) :
254 PK_Ops::Verification_with_Hash(options), m_key(key) {}
256 DSA_Verification_Operation(
const std::shared_ptr<const DL_PublicKey>& key,
const AlgorithmIdentifier& alg_id) :
257 PK_Ops::Verification_with_Hash(alg_id,
"DSA"), m_key(key) {}
259 bool verify(std::span<const uint8_t> input, std::span<const uint8_t> sig)
override;
262 std::shared_ptr<const DL_PublicKey> m_key;
265bool DSA_Verification_Operation::verify(std::span<const uint8_t> input, std::span<const uint8_t> sig) {
266 const auto group = m_key->group();
268 const BigInt& q = group.get_q();
269 const size_t q_bytes = q.bytes();
271 if(sig.size() != 2 * q_bytes) {
275 const BigInt r(sig.first(q_bytes));
276 BigInt s(sig.last(q_bytes));
278 if(r == 0 || r >= q || s == 0 || s >= q) {
282 BigInt i = BigInt::from_bytes_with_max_bits(input.data(), input.size(), group.q_bits());
287 s = group.inverse_mod_q(s);
294 const BigInt sr = group.multiply_mod_q(s, r);
295 const BigInt si = group.multiply_mod_q(s, i);
297 s = group.multi_exponentiate(si, m_key->public_key(), sr);
300 return (s % group.get_q() == r);
309 return std::make_unique<DSA_Verification_Operation>(this->m_public_key, options);
314 if(provider ==
"base" || provider.empty()) {
315 return std::make_unique<DSA_Verification_Operation>(this->m_public_key, signature_algorithm);
325 return std::make_unique<DSA_Signature_Operation>(this->m_private_key, options, rng);
virtual OID object_identifier() const
static BigInt random_integer(RandomNumberGenerator &rng, const BigInt &min, const BigInt &max)
static BigInt from_s32(int32_t n)
std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &options) const override
secure_vector< uint8_t > private_key_bits() const override
bool check_key(RandomNumberGenerator &rng, bool strong) const override
secure_vector< uint8_t > raw_private_key_bits() const override
std::unique_ptr< Public_Key > public_key() const override
const BigInt & get_int_field(std::string_view field) const override
std::optional< size_t > _signature_element_size_for_DER_encoding() const override
std::vector< uint8_t > raw_public_key_bits() const override
std::unique_ptr< PK_Ops::Verification > _create_verification_op(const PK_Signature_Options_Reader &options) const override
DSA_PublicKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
size_t estimated_strength() const override
std::unique_ptr< PK_Ops::Verification > create_x509_verification_op(const AlgorithmIdentifier &signature_algorithm, std::string_view provider) const override
friend class DSA_PrivateKey
bool check_key(RandomNumberGenerator &rng, bool strong) const override
std::vector< uint8_t > public_key_bits() const override
AlgorithmIdentifier algorithm_identifier() const override
const BigInt & get_int_field(std::string_view field) const override
std::string algo_name() const override
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
size_t key_length() const override
constexpr void unpoison_all(const Ts &... ts)
constexpr void poison(const T *p, size_t n)
bool signature_consistency_check(RandomNumberGenerator &rng, const Private_Key &private_key, const Public_Key &public_key, std::string_view padding)
BigInt generate_rfc6979_nonce(const BigInt &x, const BigInt &q, const BigInt &h, std::string_view hash)
BigInt ct_modulo(const BigInt &x, const BigInt &y)
void require_software_provider(const OptionsT &options, std::string_view algo_name)
std::vector< T, secure_allocator< T > > secure_vector