8#include <botan/elgamal.h>
10#include <botan/internal/blinding.h>
11#include <botan/internal/buffer_stuffer.h>
12#include <botan/internal/ct_utils.h>
13#include <botan/internal/dl_scheme.h>
14#include <botan/internal/keypair.h>
15#include <botan/internal/monty_exp.h>
16#include <botan/internal/pk_ops_impl.h>
17#include <botan/internal/pk_options_impl.h>
22 m_public_key = std::make_shared<DL_PublicKey>(group, y);
30 return m_public_key->estimated_strength();
34 return m_public_key->p_bits();
42 return m_public_key->public_key_as_bytes();
46 return m_public_key->DER_encode();
50 return m_public_key->get_int_field(
algo_name(), field);
54 return std::make_unique<ElGamal_PrivateKey>(rng, m_public_key->group());
58 return m_public_key->check_key(rng, strong);
62 m_private_key = std::make_shared<DL_PrivateKey>(group, rng);
63 m_public_key = m_private_key->public_key();
67 m_private_key = std::make_shared<DL_PrivateKey>(group, x);
68 m_public_key = m_private_key->public_key();
73 m_public_key = m_private_key->public_key();
81 return m_private_key->get_int_field(
algo_name(), field);
85 return m_private_key->DER_encode();
89 return m_private_key->raw_private_key_bits();
93 if(!m_private_key->check_key(rng, strong)) {
101#if defined(BOTAN_HAS_OAEP) && defined(BOTAN_HAS_SHA_256)
102 const std::string padding =
"OAEP(SHA-256)";
104 const std::string padding =
"Raw";
115class ElGamal_Encryption_Operation final :
public PK_Ops::Encryption_with_Padding {
117 ElGamal_Encryption_Operation(
const std::shared_ptr<const DL_PublicKey>& key,
119 PK_Ops::Encryption_with_Padding(options), m_key(key) {
120 const size_t powm_window = 4;
121 m_monty_y_p =
monty_precompute(m_key->group()._monty_params_p(), m_key->public_key(), powm_window);
124 size_t ciphertext_length(
size_t )
const override {
return 2 * m_key->group().p_bytes(); }
126 size_t max_ptext_input_bits()
const override {
return m_key->group().p_bits() - 1; }
128 std::vector<uint8_t> raw_encrypt(std::span<const uint8_t> ptext, RandomNumberGenerator& rng)
override;
131 std::shared_ptr<const DL_PublicKey> m_key;
132 std::shared_ptr<const Montgomery_Exponentiation_State> m_monty_y_p;
135std::vector<uint8_t> ElGamal_Encryption_Operation::raw_encrypt(std::span<const uint8_t> ptext,
137 const BigInt m(ptext);
139 const auto& group = m_key->group();
141 if(m == 0 || m >= group.get_p()) {
142 throw Invalid_Argument(
"ElGamal encryption: Message out of valid plaintext range");
153 const size_t k_bits = group.p_bits() - 1;
154 const BigInt k(rng, k_bits,
false);
156 const auto scope = CT::scoped_poison(m, k);
158 const BigInt a = group.power_g_p(k, k_bits);
159 const BigInt b = group.multiply_mod_p(m,
monty_execute(*m_monty_y_p, k, k_bits).value());
160 CT::unpoison_all(a, b);
162 const size_t p_bytes = group.p_bytes();
163 std::vector<uint8_t> ctext(2 * p_bytes);
164 BufferStuffer stuffer(ctext);
165 a.serialize_to(stuffer.next(p_bytes));
166 b.serialize_to(stuffer.next(p_bytes));
173class ElGamal_Decryption_Operation final :
public PK_Ops::Decryption_with_Padding {
175 ElGamal_Decryption_Operation(
const std::shared_ptr<const DL_PrivateKey>& key,
176 const PK_Encryption_Options_Reader& options,
177 RandomNumberGenerator& rng) :
178 PK_Ops::Decryption_with_Padding(options),
181 m_key->group()._reducer_mod_p(),
183 [](const BigInt& k) {
return k; },
184 [
this](
const BigInt& k) {
return powermod_x_p(k); }) {}
186 size_t plaintext_length(
size_t )
const override {
return m_key->group().p_bytes(); }
188 size_t ciphertext_length(
size_t )
const override {
return 2 * m_key->group().p_bytes(); }
190 secure_vector<uint8_t> raw_decrypt(std::span<const uint8_t> ctext)
override;
193 BigInt powermod_x_p(
const BigInt& v)
const {
194 return m_key->group().power_b_p(v, m_key->private_key(), m_key->max_private_key_bits());
197 std::shared_ptr<const DL_PrivateKey> m_key;
202 const auto& group = m_key->group();
204 const size_t p_bytes = group.p_bytes();
206 if(ctext.size() != 2 * p_bytes) {
207 throw Invalid_Argument(
"ElGamal decryption: Invalid message");
210 BigInt a(ctext.first(p_bytes));
211 const BigInt b(ctext.last(p_bytes));
213 if(!group.verify_public_element(a)) {
214 throw Invalid_Argument(
"ElGamal decryption: Invalid message");
217 if(b == 0 || b >= group.get_p()) {
218 throw Invalid_Argument(
"ElGamal decryption: Invalid message");
221 const auto scope = CT::scoped_poison(m_key->private_key(), m_blinder);
223 a = m_blinder.
blind(a);
225 const BigInt r = group.multiply_mod_p(group.inverse_mod_p(powermod_x_p(a)), b);
228 const BigInt ptext = m_blinder.
unblind(r);
231 return ptext.serialize<secure_vector<uint8_t>>(p_bytes);
241 return std::make_unique<ElGamal_Encryption_Operation>(this->m_public_key, options);
248 return std::make_unique<ElGamal_Decryption_Operation>(this->m_private_key, options, rng);
virtual OID object_identifier() const
BigInt blind(const BigInt &x) const
BigInt unblind(const BigInt &x) const
std::unique_ptr< PK_Ops::Decryption > _create_decryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const override
secure_vector< uint8_t > private_key_bits() const override
const BigInt & get_int_field(std::string_view field) const override
bool check_key(RandomNumberGenerator &rng, bool strong) const override
std::unique_ptr< Public_Key > public_key() const override
secure_vector< uint8_t > raw_private_key_bits() const override
const BigInt & get_int_field(std::string_view field) const override
std::unique_ptr< PK_Ops::Encryption > _create_encryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const override
std::vector< uint8_t > public_key_bits() const override
friend class ElGamal_PrivateKey
size_t estimated_strength() const override
bool check_key(RandomNumberGenerator &rng, bool strong) const override
AlgorithmIdentifier algorithm_identifier() const override
std::vector< uint8_t > raw_public_key_bits() const override
size_t key_length() const override
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
std::string algo_name() const override
ElGamal_PublicKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
bool encryption_consistency_check(RandomNumberGenerator &rng, const Private_Key &private_key, const Public_Key &public_key, std::string_view padding)
std::shared_ptr< const Montgomery_Exponentiation_State > monty_precompute(const Montgomery_Int &g, size_t window_bits)
void require_software_provider(const OptionsT &options, std::string_view algo_name)
std::vector< T, secure_allocator< T > > secure_vector
Montgomery_Int monty_execute(const Montgomery_Exponentiation_State &precomputed_state, const BigInt &k, size_t max_k_bits)