9#include <botan/pk_options_readers.h>
12#include <botan/ec_group.h>
13#include <botan/hash.h>
14#include <botan/internal/ct_utils.h>
15#include <botan/internal/fmt.h>
16#include <botan/internal/keypair.h>
17#include <botan/internal/loadstor.h>
18#include <botan/internal/mem_utils.h>
19#include <botan/internal/pk_ops_impl.h>
20#include <botan/internal/pk_options_impl.h>
33 if(alg_name !=
"SM2" && alg_name !=
"SM2_Enc" && alg_name !=
"ECDSA") {
34 throw Decoding_Error(
fmt(
"Unexpected AlgorithmIdentifier OID {} in association with SM2 key", alg_id.
oid()));
43 EC_PublicKey(assert_sm2_algorithm_identifier(alg_id), key_bits) {}
75 EC_PrivateKey(assert_sm2_algorithm_identifier(alg_id), key_bits),
77 m_da_inv_legacy(m_da_inv.to_bigint()) {
78 if(m_da_inv.is_zero()) {
79 throw Decoding_Error(
"SM2 private key cannot equal n-1");
86 m_da_inv_legacy(m_da_inv.to_bigint()) {
87 if(m_da_inv.is_zero()) {
88 throw Decoding_Error(
"SM2 private key cannot equal n-1");
102 if((x + one).is_nonzero()) {
116 m_da_inv_legacy(m_da_inv.to_bigint()) {
117 if(m_da_inv.is_zero()) {
118 throw Decoding_Error(
"SM2 private key cannot equal n-1");
122#if defined(BOTAN_HAS_LEGACY_EC_POINT)
124 std::string_view user_id,
135 std::span<const uint8_t> user_id,
136 const EC_Group& group,
137 const EC_AffinePoint& pubkey) {
138 if(user_id.size() >= 8192) {
139 throw Invalid_Argument(
"SM2 user id too long to represent");
142 const uint16_t uid_len =
static_cast<uint16_t
>(8 * user_id.size());
146 hash.update(user_id);
148 const size_t p_bytes = group.get_p_bytes();
150 hash.update(group.get_a().serialize(p_bytes));
151 hash.update(group.get_b().serialize(p_bytes));
152 hash.update(group.get_g_x().serialize(p_bytes));
153 hash.update(group.get_g_y().serialize(p_bytes));
154 hash.update(pubkey.xy_bytes());
156 return hash.final<std::vector<uint8_t>>();
162 std::string_view user_id,
172std::vector<uint8_t> sm2_default_userid() {
175 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
176 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
183 return options.hash_function().value_or(
"SM3");
191class SM2_Signature_Input final {
193 SM2_Signature_Input(
const PK_Signature_Options_Reader& options,
194 const EC_Group& group,
195 const EC_AffinePoint& pubkey) :
197 if(options.using_externally_computed_prehash()) {
198 if(auto prehash = externally_computed_prehash_name(options)) {
199 m_prehash_name = *prehash;
200 m_expected_digest_len = HashFunction::create_or_throw(*prehash)->output_length();
203 auto context = options.context().value_or(sm2_default_userid());
208 m_hash->update(m_za);
212 void update(std::span<const uint8_t> input) {
214 m_hash->update(input);
216 m_digest.insert(m_digest.end(), input.begin(), input.end());
224 m_hash->update(m_za);
229 std::swap(digest, m_digest);
231 if(m_expected_digest_len > 0 && digest.size() != m_expected_digest_len) {
232 throw Invalid_Argument(
fmt(
"SM2 was configured to use a {} byte {} prehash but was given {} bytes",
233 m_expected_digest_len,
241 std::string hash_function()
const {
243 return m_hash->name();
245 return m_prehash_name.empty() ?
"Raw" : m_prehash_name;
250 std::vector<uint8_t> m_za;
251 std::unique_ptr<HashFunction> m_hash;
253 std::string m_prehash_name;
254 size_t m_expected_digest_len = 0;
262 SM2_Signature_Operation(
const SM2_PrivateKey& sm2,
const PK_Signature_Options_Reader& options) :
263 m_group(sm2.domain()),
264 m_x(sm2._private_key()),
265 m_da_inv(sm2._get_da_inv()),
266 m_input(options, m_group, sm2.public_ec_point()) {}
268 size_t signature_length()
const override {
return 2 * m_group.get_order_bytes(); }
270 void update(std::span<const uint8_t> input)
override { m_input.update(input); }
272 std::vector<uint8_t> sign(RandomNumberGenerator& rng)
override;
274 std::string hash_function()
const override {
return m_input.hash_function(); }
277 const EC_Group m_group;
279 const EC_Scalar m_da_inv;
280 SM2_Signature_Input m_input;
284 const auto e = m_input.final_e();
286 const auto scope = CT::scoped_poison(m_x, m_da_inv);
288 const auto k = EC_Scalar::random(m_group, rng);
291 const auto r = EC_Scalar::gk_x_mod_order(k, rng) + e;
292 const auto s = (k - r * m_x) * m_da_inv;
294 CT::unpoison_all(r, s);
296 const auto rs = r + s;
299 if(r.is_zero() || s.is_zero() || rs.is_zero()) {
303 return EC_Scalar::serialize_pair(r, s);
309class SM2_Verification_Operation final :
public PK_Ops::Verification {
311 SM2_Verification_Operation(
const SM2_PublicKey& sm2,
const PK_Signature_Options_Reader& options) :
312 m_group(sm2.domain()), m_gy_mul(sm2.public_ec_point()), m_input(options, m_group, sm2.public_ec_point()) {}
314 void update(std::span<const uint8_t> input)
override { m_input.update(input); }
316 bool is_valid_signature(std::span<const uint8_t> sig)
override;
318 std::string hash_function()
const override {
return m_input.hash_function(); }
321 const EC_Group m_group;
322 const EC_Group::Mul2Table m_gy_mul;
323 SM2_Signature_Input m_input;
326bool SM2_Verification_Operation::is_valid_signature(std::span<const uint8_t> sig) {
327 const auto e = m_input.final_e();
329 if(
auto rs = EC_Scalar::deserialize_pair(m_group, sig)) {
330 const auto& [r, s] = rs.value();
332 if(r.is_nonzero() && s.is_nonzero()) {
333 const auto t = r + s;
346 return std::make_unique<SM2_PrivateKey>(rng,
domain());
353 return std::make_unique<SM2_Verification_Operation>(*
this, options);
362 return std::make_unique<SM2_Signature_Operation>(*
this, options);
#define BOTAN_ASSERT_NOMSG(expr)
bool mul2_vartime_x_mod_order_eq(const EC_Scalar &v, const EC_Scalar &x, const EC_Scalar &y) const
size_t get_order_bytes() const
const EC_Scalar & _private_key() const
const BigInt & private_value() const
EC_PrivateKey(const EC_PrivateKey &other)=default
bool check_key(RandomNumberGenerator &rng, bool strong) const override
const EC_Group & domain() const
const EC_AffinePoint & public_ec_point() const
EC_PublicKey(const EC_PublicKey &other)=default
static EC_Scalar one(const EC_Group &group)
static EC_Scalar from_bytes_mod_order(const EC_Group &group, std::span< const uint8_t > bytes)
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="")
std::optional< std::string > registered_name() 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
SM2_PrivateKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
bool check_key(RandomNumberGenerator &rng, bool strong) const override
std::unique_ptr< PK_Ops::Verification > _create_verification_op(const PK_Signature_Options_Reader &options) const override
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
std::optional< size_t > _signature_element_size_for_DER_encoding() const override
std::string algo_name() const override
bool signature_consistency_check(RandomNumberGenerator &rng, const Private_Key &private_key, const Public_Key &public_key, std::string_view padding)
constexpr uint8_t get_byte(T input)
std::span< const uint8_t > as_span_of_bytes(const char *s, size_t len)
std::string fmt(std::string_view format, const T &... args)
void require_software_provider(const OptionsT &options, std::string_view algo_name)
std::vector< T, secure_allocator< T > > secure_vector
std::vector< uint8_t > sm2_compute_za(HashFunction &hash, std::string_view user_id, const EC_Group &group, const EC_AffinePoint &pubkey)