10#include <botan/ber_dec.h>
11#include <botan/der_enc.h>
12#include <botan/ec_group.h>
13#include <botan/hash.h>
15#include <botan/mem_ops.h>
16#include <botan/pk_ops.h>
17#include <botan/pk_options_readers.h>
18#include <botan/internal/ct_utils.h>
19#include <botan/internal/fmt.h>
20#include <botan/internal/pk_options_impl.h>
29 m_group(key.domain()), m_peer(key.public_ec_point()) {
34 size_t max_input_bits()
const override {
39 size_t ciphertext_length(
size_t ptext_len)
const override {
40 const size_t elem_size = m_group.get_order_bytes();
41 const size_t der_overhead = 16;
43 return der_overhead + 2 * elem_size + m_hash->output_length() + ptext_len;
46 std::vector<uint8_t>
encrypt(std::span<const uint8_t> msg, RandomNumberGenerator& rng)
override {
56 const EC_AffinePoint kPB = m_peer.mul(k, rng);
58 const auto x2_bytes = kPB.x_bytes();
59 const auto y2_bytes = kPB.y_bytes();
62 kdf_input += x2_bytes;
63 kdf_input += y2_bytes;
65 const auto kdf_output = m_kdf->derive_key(msg.size(), kdf_input);
71 if(!msg.empty() &&
CT::all_zeros(kdf_output.data(), kdf_output.size()).as_bool()) {
75 std::vector<uint8_t> masked_msg(msg.size());
76 xor_buf(masked_msg, msg, kdf_output);
78 m_hash->update(x2_bytes);
80 m_hash->update(y2_bytes);
81 const auto C3 = m_hash->final<std::vector<uint8_t>>();
85 std::vector<uint8_t> ctext;
88 .encode(BigInt(C1.x_bytes()))
89 .encode(BigInt(C1.y_bytes()))
99 const EC_Group m_group;
100 const EC_AffinePoint m_peer;
101 std::unique_ptr<HashFunction> m_hash;
102 std::unique_ptr<KDF> m_kdf;
108 RandomNumberGenerator& rng,
109 std::string_view kdf_hash) :
110 m_group(key.domain()), m_x(key._private_key()), m_rng(rng) {
113 const std::string kdf_name =
fmt(
"KDF2({})", kdf_hash);
117 size_t plaintext_length(
size_t ptext_len)
const override {
122 const size_t elem_size = m_group.get_order_bytes();
124 if(ptext_len < 2 * elem_size + m_hash->output_length()) {
128 return ptext_len - (2 * elem_size + m_hash->output_length());
131 size_t ciphertext_length(
size_t ptext_len)
const override {
132 const size_t elem_size = m_group.get_order_bytes();
133 const size_t der_overhead = 16;
135 return der_overhead + 2 * elem_size + m_hash->output_length() + ptext_len;
138 size_t decrypt(uint8_t& valid_mask, std::span<uint8_t> ptext, std::span<const uint8_t> ctext)
override {
139 const size_t p_bytes = m_group.get_p_bytes();
144 if(ctext.size() < 1 + p_bytes * 2 + m_hash->output_length()) {
163 if(C3.size() != m_hash->output_length()) {
168 if(masked_msg.size() > ptext.size()) {
181 const auto dbC1 = C1->mul(m_x, m_rng);
182 const auto x2_bytes = dbC1.x_bytes();
183 const auto y2_bytes = dbC1.y_bytes();
185 const auto kdf_output = m_kdf->derive_key(masked_msg.size(), dbC1.xy_bytes());
191 const auto kdf_nonzero =
194 xor_buf(masked_msg.data(), kdf_output.data(), kdf_output.size());
196 m_hash->update(x2_bytes);
197 m_hash->update(masked_msg);
198 m_hash->update(y2_bytes);
199 const auto u = m_hash->final();
202 valid_mask = mac_ok.if_set_return(0xFF);
205 (~mac_ok).if_set_zero_out(masked_msg.data(), masked_msg.size());
206 copy_mem(ptext.first(masked_msg.size()), masked_msg);
211 const EC_Group m_group;
213 RandomNumberGenerator& m_rng;
214 std::unique_ptr<HashFunction> m_hash;
215 std::unique_ptr<KDF> m_kdf;
227 return std::make_unique<SM2_Encryption_Operation>(*
this, options.
hash_function().value_or(
"SM3"));
234 return std::make_unique<SM2_Decryption_Operation>(*
this, rng, options.
hash_function().value_or(
"SM3"));
static constexpr Mask< T > set()
static constexpr Mask< T > expand(T v)
static std::optional< EC_AffinePoint > from_bigint_xy(const EC_Group &group, const BigInt &x, const BigInt &y)
static EC_AffinePoint g_mul(const EC_Scalar &scalar, RandomNumberGenerator &rng)
Multiply by the group generator returning a complete point.
static EC_Scalar random(const EC_Group &group, RandomNumberGenerator &rng)
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
static std::unique_ptr< KDF > create_or_throw(std::string_view algo_spec, std::string_view provider="")
const std::optional< std::string > & hash_function() const
std::unique_ptr< PK_Ops::Decryption > _create_decryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const override
std::unique_ptr< PK_Ops::Encryption > _create_encryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const override
std::string algo_name() const override
constexpr auto scoped_poison(const Ts &... xs)
constexpr CT::Mask< T > is_equal(const T x[], const T y[], size_t len)
constexpr void unpoison_all(const Ts &... ts)
constexpr void unpoison(const T *p, size_t n)
constexpr CT::Mask< T > all_zeros(const T elem[], size_t len)
constexpr void poison(const T *p, size_t n)
std::string decrypt(std::span< const uint8_t > input, std::string_view passphrase)
std::string encrypt(const uint8_t input[], size_t input_len, std::string_view passphrase, RandomNumberGenerator &rng)
SM2_PublicKey SM2_Encryption_PublicKey
std::string fmt(std::string_view format, const T &... args)
constexpr void copy_mem(T *out, const T *in, size_t n)
void require_software_provider(const OptionsT &options, std::string_view algo_name)
SM2_PrivateKey SM2_Encryption_PrivateKey
constexpr void xor_buf(ranges::contiguous_output_range< uint8_t > auto &&out, ranges::contiguous_range< uint8_t > auto &&in)
std::vector< T, secure_allocator< T > > secure_vector