10#include <botan/gost_3410.h>
12#include <botan/assert.h>
13#include <botan/ber_dec.h>
14#include <botan/der_enc.h>
15#include <botan/internal/ct_utils.h>
16#include <botan/internal/ec_key_data.h>
17#include <botan/internal/fmt.h>
18#include <botan/internal/pk_ops_impl.h>
19#include <botan/internal/pk_options_impl.h>
27 if(p_bits != 256 && p_bits != 512) {
28 throw Decoding_Error(
fmt(
"GOST-34.10-2012 is not defined for parameters of size {}", p_bits));
33bool is_gost_3410_key_oid(
const OID& oid) {
39 if(!is_gost_3410_key_oid(alg_id.oid())) {
41 fmt(
"Unexpected AlgorithmIdentifier OID {} in association with GOST 34.10 key", alg_id.oid()));
51 auto params = outer.start_sequence();
52 params.decode(ecc_param_id);
54 if(params.more_items()) {
56 params.decode(digest_param_id);
60 throw Decoding_Error(
"Unexpected digest parameters for GOST-34.10-2012-256 public key");
65 throw Decoding_Error(
"Unexpected digest parameters for GOST-34.10-2012-512 public key");
69 if(params.more_items()) {
71 throw Decoding_Error(
"Unexpected extra parameters for GOST-34.10-2012 public key");
74 OID encryption_param_id;
75 params.decode(encryption_param_id);
84void check_gost_key_oid_matches_group(
const OID& key_oid,
const EC_Group& group) {
85 if(key_oid ==
OID::from_string(
"GOST-34.10-2012-256") && group.get_p_bits() != 256) {
86 throw Decoding_Error(
"GOST-34.10-2012-256 public key has unexpected parameters");
89 if(key_oid ==
OID::from_string(
"GOST-34.10-2012-512") && group.get_p_bits() != 512) {
90 throw Decoding_Error(
"GOST-34.10-2012-512 public key has unexpected parameters");
95 assert_gost_algorithm_identifier(alg_id);
100 decoder.decode(ecc_param_id).verify_end();
102 ecc_param_id = decode_gost_key_parameters(alg_id);
106 check_gost_key_oid_matches_group(alg_id.oid(), group);
120 const size_t part_size = bits.size() / 2;
123 for(
size_t i = 0; i != part_size / 2; ++i) {
124 std::swap(bits[i], bits[part_size - 1 - i]);
125 std::swap(bits[part_size + i], bits[2 * part_size - 1 - i]);
128 std::vector<uint8_t> output;
136 if(p_bits == 256 || p_bits == 512) {
137 return fmt(
"GOST-34.10-2012-{}", p_bits);
139 throw Encoding_Error(
"GOST-34.10-2012 is not defined for parameters of this size");
144 std::vector<uint8_t> params;
155 assert_gost_algorithm_identifier(alg_id);
157 const OID ecc_param_id = decode_gost_key_parameters(alg_id);
160 check_gost_key_oid_matches_group(alg_id.
oid(), group);
162 std::vector<uint8_t> bits;
165 if(bits.size() != 2 * (group.get_p_bits() / 8)) {
166 throw Decoding_Error(
"GOST-34.10-2012 invalid encoding of public key");
169 const size_t part_size = bits.size() / 2;
172 std::vector<uint8_t> encoding;
173 encoding.reserve(bits.size() + 1);
175 encoding.insert(encoding.end(), bits.rbegin() + part_size, bits.rend());
176 encoding.insert(encoding.end(), bits.rbegin(), bits.rend() - part_size);
178 m_public_key = std::make_shared<EC_PublicKey_Data>(group, encoding);
199EC_Scalar gost_msg_to_scalar(
const EC_Group& group, std::span<const uint8_t> msg) {
200 std::vector<uint8_t> rev_bytes(msg.rbegin(), msg.rend());
215 GOST_3410_Signature_Operation(
const GOST_3410_PrivateKey& gost_3410,
const PK_Signature_Options_Reader& options) :
216 PK_Ops::Signature_with_Hash(options), m_group(gost_3410.domain()), m_x(gost_3410._private_key()) {}
218 size_t signature_length()
const override {
return 2 * m_group.get_order_bytes(); }
220 AlgorithmIdentifier algorithm_identifier()
const override;
222 std::vector<uint8_t> raw_sign(std::span<const uint8_t> msg, RandomNumberGenerator& rng)
override;
225 const EC_Group m_group;
230 const std::string hash_fn = hash_function();
234 std::string oid_name;
235 if(hash_fn ==
"GOST-R-34.11-94") {
236 oid_name =
"GOST-34.10/GOST-R-34.11-94";
237 }
else if(hash_fn ==
"Streebog-256" && p_bits == 256) {
238 oid_name =
"GOST-34.10-2012-256/Streebog-256";
239 }
else if(hash_fn ==
"Streebog-512" && p_bits == 512) {
240 oid_name =
"GOST-34.10-2012-512/Streebog-512";
241 }
else if(hash_fn ==
"SHA-256" && p_bits == 256) {
242 oid_name =
"GOST-34.10-2012-256/SHA-256";
245 if(oid_name.empty()) {
246 throw Not_Implemented(
"No encoding defined for GOST with " + hash_fn);
249 return AlgorithmIdentifier(oid_name, AlgorithmIdentifier::USE_EMPTY_PARAM);
252std::vector<uint8_t> GOST_3410_Signature_Operation::raw_sign(std::span<const uint8_t> msg, RandomNumberGenerator& rng) {
253 const auto e = gost_msg_to_scalar(m_group, msg);
255 const auto scope = CT::scoped_poison(m_x);
257 const auto k = EC_Scalar::random(m_group, rng);
259 const auto r = EC_Scalar::gk_x_mod_order(k, rng);
260 const auto s = (r * m_x) + (k * e);
262 CT::unpoison_all(r, s);
264 if(r.is_zero() || s.is_zero()) {
265 throw Internal_Error(
"GOST 34.10 signature generation failed, r/s equal to zero");
268 return EC_Scalar::serialize_pair(s, r);
271PK_Signature_Options gost_hash_from_algid(
const AlgorithmIdentifier& alg_id) {
272 if(!alg_id.parameters_are_empty()) {
273 throw Decoding_Error(
"Unexpected non-empty AlgorithmIdentifier parameters for GOST 34.10 signature");
276 if(
const auto name = alg_id.oid().registered_name()) {
277 if(*
name ==
"GOST-34.10/GOST-R-34.11-94") {
278 return PK_Signature_Options().with_hash(
"GOST-R-34.11-94");
279 }
else if(*
name ==
"GOST-34.10-2012-256/Streebog-256") {
280 return PK_Signature_Options().with_hash(
"Streebog-256");
281 }
else if(*
name ==
"GOST-34.10-2012-512/Streebog-512") {
282 return PK_Signature_Options().with_hash(
"Streebog-512");
283 }
else if(*
name ==
"GOST-34.10-2012-256/SHA-256") {
284 return PK_Signature_Options().with_hash(
"SHA-256");
286 throw Decoding_Error(
fmt(
"Unknown OID ({}, {}) for GOST 34.10 signatures", alg_id.oid(), *
name));
289 throw Decoding_Error(
fmt(
"Unknown OID ({}) for GOST 34.10 signatures", alg_id.oid()));
296class GOST_3410_Verification_Operation final :
public PK_Ops::Verification_with_Hash {
298 GOST_3410_Verification_Operation(
const GOST_3410_PublicKey& gost,
const PK_Signature_Options_Reader& options) :
299 PK_Ops::Verification_with_Hash(options), m_group(gost.domain()), m_gy_mul(gost.public_ec_point()) {}
301 GOST_3410_Verification_Operation(
const GOST_3410_PublicKey& gost,
const AlgorithmIdentifier& alg_id) :
302 PK_Ops::Verification_with_Hash(PK_Options_Reader_Access::for_verification(gost_hash_from_algid(alg_id))),
303 m_group(gost.domain()),
304 m_gy_mul(gost.public_ec_point()) {}
306 bool verify(std::span<const uint8_t> msg, std::span<const uint8_t> sig)
override;
309 const EC_Group m_group;
310 const EC_Group::Mul2Table m_gy_mul;
313bool GOST_3410_Verification_Operation::verify(std::span<const uint8_t> msg, std::span<const uint8_t> sig) {
314 if(
auto sr = EC_Scalar::deserialize_pair(m_group, sig)) {
315 const auto& [s, r] = sr.value();
317 if(r.is_nonzero() && s.is_nonzero()) {
318 const auto e = gost_msg_to_scalar(m_group, msg);
320 const auto v = e.invert_vartime();
333 return std::make_unique<GOST_3410_PrivateKey>(rng,
domain());
340 return std::make_unique<GOST_3410_Verification_Operation>(*
this, options);
345 if(provider ==
"base" || provider.empty()) {
346 return std::make_unique<GOST_3410_Verification_Operation>(*
this, signature_algorithm);
358 return std::make_unique<GOST_3410_Signature_Operation>(*
this, options);
virtual OID object_identifier() const
void push_back(const BER_Object &obj)
BER_Decoder & decode(bool &out)
BER_Decoder & verify_end()
DER_Encoder & start_sequence()
DER_Encoder & encode(bool b)
bool mul2_vartime_x_mod_order_eq(const EC_Scalar &v, const EC_Scalar &x, const EC_Scalar &y) const
size_t get_p_bits() const
static EC_Group from_OID(const OID &oid)
const OID & get_curve_oid() const
size_t get_order_bytes() const
EC_PrivateKey(const EC_PrivateKey &other)=default
const EC_Group & domain() const
const EC_AffinePoint & public_ec_point() const
std::shared_ptr< const EC_PublicKey_Data > m_public_key
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)
std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &options) const override
std::unique_ptr< Public_Key > public_key() const override
GOST_3410_PrivateKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
AlgorithmIdentifier algorithm_identifier() const override
std::unique_ptr< PK_Ops::Verification > _create_verification_op(const PK_Signature_Options_Reader &options) const override
GOST_3410_PublicKey()=default
std::string algo_name() const override
std::unique_ptr< PK_Ops::Verification > create_x509_verification_op(const AlgorithmIdentifier &signature_algorithm, std::string_view provider) const override
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
std::vector< uint8_t > public_key_bits() const override
std::optional< size_t > _signature_element_size_for_DER_encoding() const override
static OID from_string(std::string_view str)
std::string fmt(std::string_view format, const T &... args)
void require_software_provider(const OptionsT &options, std::string_view algo_name)