Botan 3.14.1
Crypto and TLS for C&
gost_3410.cpp
Go to the documentation of this file.
1/*
2* GOST 34.10-2012
3* (C) 2007 Falko Strenzke, FlexSecure GmbH
4* Manuel Hartl, FlexSecure GmbH
5* (C) 2008-2010,2015,2018,2024 Jack Lloyd
6*
7* Botan is released under the Simplified BSD License (see license.txt)
8*/
9
10#include <botan/gost_3410.h>
11
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>
20
21namespace Botan {
22
23namespace {
24
25EC_Group check_domain(EC_Group domain) {
26 const size_t p_bits = domain.get_p_bits();
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));
29 }
30 return domain;
31}
32
33bool is_gost_3410_key_oid(const OID& oid) {
34 return oid == OID::from_string("GOST-34.10") || oid == OID::from_string("GOST-34.10-2012-256") ||
35 oid == OID::from_string("GOST-34.10-2012-512");
36}
37
38const AlgorithmIdentifier& assert_gost_algorithm_identifier(const AlgorithmIdentifier& alg_id) {
39 if(!is_gost_3410_key_oid(alg_id.oid())) {
40 throw Decoding_Error(
41 fmt("Unexpected AlgorithmIdentifier OID {} in association with GOST 34.10 key", alg_id.oid()));
42 }
43
44 return alg_id; // NOLINT(*-return-const-ref-from-parameter)
45}
46
47OID decode_gost_key_parameters(const AlgorithmIdentifier& alg_id) {
48 OID ecc_param_id;
49
50 auto outer = BER_Decoder(alg_id.parameters(), BER_Decoder::Limits::DER());
51 auto params = outer.start_sequence();
52 params.decode(ecc_param_id);
53
54 if(params.more_items()) {
55 OID digest_param_id;
56 params.decode(digest_param_id);
57
58 if(alg_id.oid() == OID::from_string("GOST-34.10-2012-256") &&
59 digest_param_id != OID::from_string("Streebog-256")) {
60 throw Decoding_Error("Unexpected digest parameters for GOST-34.10-2012-256 public key");
61 }
62
63 if(alg_id.oid() == OID::from_string("GOST-34.10-2012-512") &&
64 digest_param_id != OID::from_string("Streebog-512")) {
65 throw Decoding_Error("Unexpected digest parameters for GOST-34.10-2012-512 public key");
66 }
67 }
68
69 if(params.more_items()) {
70 if(alg_id.oid() != OID::from_string("GOST-34.10")) {
71 throw Decoding_Error("Unexpected extra parameters for GOST-34.10-2012 public key");
72 }
73
74 OID encryption_param_id;
75 params.decode(encryption_param_id);
76 }
77
78 params.verify_end();
79 outer.verify_end();
80
81 return ecc_param_id;
82}
83
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");
87 }
88
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");
91 }
92}
93
94AlgorithmIdentifier gost_private_key_alg_id(const AlgorithmIdentifier& alg_id) {
95 assert_gost_algorithm_identifier(alg_id);
96
97 OID ecc_param_id;
98 BER_Decoder decoder(alg_id.parameters(), BER_Decoder::Limits::DER());
99 if(decoder.peek_next_object().type_tag() == ASN1_Type::ObjectId) {
100 decoder.decode(ecc_param_id).verify_end();
101 } else {
102 ecc_param_id = decode_gost_key_parameters(alg_id);
103 }
104
105 const auto group = check_domain(EC_Group::from_OID(ecc_param_id));
106 check_gost_key_oid_matches_group(alg_id.oid(), group);
107
108 return AlgorithmIdentifier(alg_id.oid(), group.DER_encode());
109}
110
111} // namespace
112
116
117std::vector<uint8_t> GOST_3410_PublicKey::public_key_bits() const {
118 auto bits = public_ec_point().xy_bytes();
119
120 const size_t part_size = bits.size() / 2;
121
122 // GOST keys are stored in little endian format (WTF)
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]);
126 }
127
128 std::vector<uint8_t> output;
130 return output;
131}
132
134 const size_t p_bits = domain().get_p_bits();
135
136 if(p_bits == 256 || p_bits == 512) {
137 return fmt("GOST-34.10-2012-{}", p_bits);
138 } else {
139 throw Encoding_Error("GOST-34.10-2012 is not defined for parameters of this size");
140 }
141}
142
144 std::vector<uint8_t> params;
145
146 const OID gost_oid = object_identifier();
147 const OID domain_oid = domain().get_curve_oid();
148
149 DER_Encoder(params).start_sequence().encode(domain_oid).end_cons();
150
151 return AlgorithmIdentifier(gost_oid, params);
152}
153
154GOST_3410_PublicKey::GOST_3410_PublicKey(const AlgorithmIdentifier& alg_id, std::span<const uint8_t> key_bits) {
155 assert_gost_algorithm_identifier(alg_id);
156
157 const OID ecc_param_id = decode_gost_key_parameters(alg_id);
158
159 const auto group = check_domain(EC_Group::from_OID(ecc_param_id));
160 check_gost_key_oid_matches_group(alg_id.oid(), group);
161
162 std::vector<uint8_t> bits;
164
165 if(bits.size() != 2 * (group.get_p_bits() / 8)) {
166 throw Decoding_Error("GOST-34.10-2012 invalid encoding of public key");
167 }
168
169 const size_t part_size = bits.size() / 2;
170
171 // Keys are stored in little endian format (WTF)
172 std::vector<uint8_t> encoding;
173 encoding.reserve(bits.size() + 1);
174 encoding.push_back(0x04);
175 encoding.insert(encoding.end(), bits.rbegin() + part_size, bits.rend());
176 encoding.insert(encoding.end(), bits.rbegin(), bits.rend() - part_size);
177
178 m_public_key = std::make_shared<EC_PublicKey_Data>(group, encoding);
179}
180
182 EC_PrivateKey(check_domain(domain), EC_Scalar::from_bigint(domain, x)) {}
183
186
189
190GOST_3410_PrivateKey::GOST_3410_PrivateKey(const AlgorithmIdentifier& alg_id, std::span<const uint8_t> key_bits) :
191 EC_PrivateKey(gost_private_key_alg_id(alg_id), key_bits) {}
192
193std::unique_ptr<Public_Key> GOST_3410_PrivateKey::public_key() const {
194 return std::make_unique<GOST_3410_PublicKey>(domain(), public_ec_point());
195}
196
197namespace {
198
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());
201
202 auto ie = EC_Scalar::from_bytes_mod_order(group, rev_bytes);
203 if(ie.is_zero()) {
204 return EC_Scalar::one(group);
205 } else {
206 return ie;
207 }
208}
209
210/**
211* GOST-34.10 signature operation
212*/
213class GOST_3410_Signature_Operation final : public PK_Ops::Signature_with_Hash {
214 public:
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()) {}
217
218 size_t signature_length() const override { return 2 * m_group.get_order_bytes(); }
219
220 AlgorithmIdentifier algorithm_identifier() const override;
221
222 std::vector<uint8_t> raw_sign(std::span<const uint8_t> msg, RandomNumberGenerator& rng) override;
223
224 private:
225 const EC_Group m_group;
226 const EC_Scalar m_x;
227};
228
229AlgorithmIdentifier GOST_3410_Signature_Operation::algorithm_identifier() const {
230 const std::string hash_fn = hash_function();
231
232 const size_t p_bits = m_group.get_p_bits();
233
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";
243 }
244
245 if(oid_name.empty()) {
246 throw Not_Implemented("No encoding defined for GOST with " + hash_fn);
247 }
248
249 return AlgorithmIdentifier(oid_name, AlgorithmIdentifier::USE_EMPTY_PARAM);
250}
251
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);
254
255 const auto scope = CT::scoped_poison(m_x);
256
257 const auto k = EC_Scalar::random(m_group, rng);
258 CT::poison(k);
259 const auto r = EC_Scalar::gk_x_mod_order(k, rng);
260 const auto s = (r * m_x) + (k * e);
261
262 CT::unpoison_all(r, s);
263
264 if(r.is_zero() || s.is_zero()) {
265 throw Internal_Error("GOST 34.10 signature generation failed, r/s equal to zero");
266 }
267
268 return EC_Scalar::serialize_pair(s, r);
269}
270
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");
274 }
275
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");
285 } else {
286 throw Decoding_Error(fmt("Unknown OID ({}, {}) for GOST 34.10 signatures", alg_id.oid(), *name));
287 }
288 } else {
289 throw Decoding_Error(fmt("Unknown OID ({}) for GOST 34.10 signatures", alg_id.oid()));
290 }
291}
292
293/**
294* GOST-34.10 verification operation
295*/
296class GOST_3410_Verification_Operation final : public PK_Ops::Verification_with_Hash {
297 public:
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()) {}
300
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()) {}
305
306 bool verify(std::span<const uint8_t> msg, std::span<const uint8_t> sig) override;
307
308 private:
309 const EC_Group m_group;
310 const EC_Group::Mul2Table m_gy_mul;
311};
312
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();
316
317 if(r.is_nonzero() && s.is_nonzero()) {
318 const auto e = gost_msg_to_scalar(m_group, msg);
319
320 const auto v = e.invert_vartime();
321
322 // Check if r == x_coord(g*v*s - y*v*r) % n
323 return m_gy_mul.mul2_vartime_x_mod_order_eq(r, v, s, r.negate());
324 }
325 }
326
327 return false;
328}
329
330} // namespace
331
332std::unique_ptr<Private_Key> GOST_3410_PublicKey::generate_another(RandomNumberGenerator& rng) const {
333 return std::make_unique<GOST_3410_PrivateKey>(rng, domain());
334}
335
336std::unique_ptr<PK_Ops::Verification> GOST_3410_PublicKey::_create_verification_op(
337 const PK_Signature_Options_Reader& options) const {
339
340 return std::make_unique<GOST_3410_Verification_Operation>(*this, options);
341}
342
343std::unique_ptr<PK_Ops::Verification> GOST_3410_PublicKey::create_x509_verification_op(
344 const AlgorithmIdentifier& signature_algorithm, std::string_view provider) const {
345 if(provider == "base" || provider.empty()) {
346 return std::make_unique<GOST_3410_Verification_Operation>(*this, signature_algorithm);
347 }
348
349 throw Provider_Not_Found(algo_name(), provider);
350}
351
352std::unique_ptr<PK_Ops::Signature> GOST_3410_PrivateKey::_create_signature_op(
353 RandomNumberGenerator& rng, const PK_Signature_Options_Reader& options) const {
354 BOTAN_UNUSED(rng);
355
357
358 return std::make_unique<GOST_3410_Signature_Operation>(*this, options);
359}
360
361} // namespace Botan
#define BOTAN_UNUSED
Definition assert.h:151
const OID & oid() const
Definition asn1_obj.h:688
virtual OID object_identifier() const
Definition pk_keys.cpp:24
static Limits DER()
Definition ber_dec.h:44
void push_back(const BER_Object &obj)
Definition ber_dec.cpp:605
BER_Decoder & decode(bool &out)
Definition ber_dec.h:361
BER_Decoder & verify_end()
Definition ber_dec.cpp:471
DER_Encoder & start_sequence()
Definition der_enc.h:86
DER_Encoder & end_cons()
Definition der_enc.cpp:208
DER_Encoder & encode(bool b)
Definition der_enc.cpp:313
bool mul2_vartime_x_mod_order_eq(const EC_Scalar &v, const EC_Scalar &x, const EC_Scalar &y) const
Definition ec_group.cpp:987
size_t get_p_bits() const
Definition ec_group.cpp:721
static EC_Group from_OID(const OID &oid)
Definition ec_group.cpp:518
const OID & get_curve_oid() const
Definition ec_group.cpp:805
size_t get_order_bytes() const
Definition ec_group.cpp:733
EC_PrivateKey(const EC_PrivateKey &other)=default
const EC_Group & domain() const
Definition ecc_key.cpp:76
const EC_AffinePoint & public_ec_point() const
Definition ecc_key.cpp:88
std::shared_ptr< const EC_PublicKey_Data > m_public_key
Definition ecc_key.h:148
static EC_Scalar one(const EC_Group &group)
Definition ec_scalar.cpp:80
static EC_Scalar from_bytes_mod_order(const EC_Group &group, std::span< const uint8_t > bytes)
Definition ec_scalar.cpp:68
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
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)
Definition asn1_oid.cpp:80
const char * name
Definition ffi_tls.h:59
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53
void require_software_provider(const OptionsT &options, std::string_view algo_name)