10#include <botan/eckcdsa.h>
12#include <botan/ec_group.h>
13#include <botan/hash.h>
14#include <botan/mem_ops.h>
15#include <botan/pk_options_readers.h>
17#include <botan/internal/concat_util.h>
18#include <botan/internal/ct_utils.h>
19#include <botan/internal/fmt.h>
20#include <botan/internal/keypair.h>
21#include <botan/internal/parsing.h>
22#include <botan/internal/pk_ops_impl.h>
23#include <botan/internal/pk_options_impl.h>
54std::unique_ptr<HashFunction> eckcdsa_signature_hash(
const AlgorithmIdentifier& alg_id) {
55 if(
const auto name = alg_id.oid().registered_name()) {
58 if(alg_info.size() == 2 && alg_info[0] ==
"ECKCDSA") {
59 if(!alg_id.parameters_are_empty()) {
60 throw Decoding_Error(
"Unexpected non-empty AlgorithmIdentifier parameters for ECKCDSA");
67 throw Decoding_Error(
fmt(
"Unexpected AlgorithmIdentifier OID {} in association with ECKCDSA key", alg_id.oid()));
70std::vector<uint8_t> eckcdsa_prefix(
const EC_AffinePoint& point,
size_t hash_block_size) {
71 auto prefix = point.xy_bytes<std::vector<uint8_t>>();
74 prefix.resize(hash_block_size);
102void truncate_hash_if_needed(std::vector<uint8_t>& digest,
size_t group_order_bytes) {
103 if(digest.size() > group_order_bytes) {
104 const size_t bytes_to_truncate = digest.size() - group_order_bytes;
105 digest.erase(digest.begin(), digest.begin() + bytes_to_truncate);
114 ECKCDSA_Signature_Operation(
const ECKCDSA_PrivateKey& eckcdsa,
const PK_Signature_Options_Reader& options) :
115 m_group(eckcdsa.domain()),
116 m_x(eckcdsa._private_key()),
117 m_hash(eckcdsa_signature_hash(options)),
118 m_prefix(eckcdsa_prefix(eckcdsa.public_ec_point(), m_hash->hash_block_size())),
119 m_prefix_used(false) {}
121 void update(std::span<const uint8_t> input)
override {
123 m_hash->update(m_prefix);
124 m_prefix_used =
true;
126 m_hash->update(input);
129 std::vector<uint8_t> sign(RandomNumberGenerator& rng)
override {
130 m_prefix_used =
false;
131 std::vector<uint8_t> digest = m_hash->final_stdvec();
132 truncate_hash_if_needed(digest, m_group.get_order_bytes());
133 return raw_sign(digest, rng);
136 size_t signature_length()
const override {
return 2 * m_group.get_order_bytes(); }
138 AlgorithmIdentifier algorithm_identifier()
const override;
140 std::string hash_function()
const override {
return m_hash->name(); }
143 std::vector<uint8_t> raw_sign(std::span<const uint8_t> msg, RandomNumberGenerator& rng);
145 const EC_Group m_group;
147 std::unique_ptr<HashFunction> m_hash;
148 std::vector<uint8_t> m_prefix;
153 const std::string full_name =
"ECKCDSA/" + m_hash->name();
154 const OID oid = OID::from_string(full_name);
155 return AlgorithmIdentifier(oid, AlgorithmIdentifier::USE_EMPTY_PARAM);
158std::vector<uint8_t> ECKCDSA_Signature_Operation::raw_sign(std::span<const uint8_t> msg, RandomNumberGenerator& rng) {
159 const auto scope = CT::scoped_poison(m_x);
161 const auto k = EC_Scalar::random(m_group, rng);
166 m_hash->update(EC_AffinePoint::g_mul(k, rng).x_bytes());
167 auto c = m_hash->final_stdvec();
175 const auto w = EC_Scalar::from_bytes_mod_order(m_group, c);
177 const auto s = m_x * (k - w);
180 throw Internal_Error(
"During ECKCDSA signature generation created zero s");
183 return concat(r, s.serialize());
189class ECKCDSA_Verification_Operation final :
public PK_Ops::Verification {
191 ECKCDSA_Verification_Operation(
const ECKCDSA_PublicKey& eckcdsa,
const PK_Signature_Options_Reader& options) :
192 m_group(eckcdsa.domain()),
193 m_gy_mul(eckcdsa.public_ec_point()),
194 m_hash(eckcdsa_signature_hash(options)),
195 m_prefix(eckcdsa_prefix(eckcdsa.public_ec_point(), m_hash->hash_block_size())),
196 m_prefix_used(false) {}
198 ECKCDSA_Verification_Operation(
const ECKCDSA_PublicKey& eckcdsa,
const AlgorithmIdentifier& alg_id) :
199 m_group(eckcdsa.domain()),
200 m_gy_mul(eckcdsa.public_ec_point()),
201 m_hash(eckcdsa_signature_hash(alg_id)),
202 m_prefix(eckcdsa_prefix(eckcdsa.public_ec_point(), m_hash->hash_block_size())),
203 m_prefix_used(false) {}
205 void update(std::span<const uint8_t> msg)
override;
207 bool is_valid_signature(std::span<const uint8_t> sig)
override;
209 std::string hash_function()
const override {
return m_hash->name(); }
212 bool verify(std::span<const uint8_t> msg, std::span<const uint8_t> sig);
214 const EC_Group m_group;
215 const EC_Group::Mul2Table m_gy_mul;
216 std::unique_ptr<HashFunction> m_hash;
217 std::vector<uint8_t> m_prefix;
221void ECKCDSA_Verification_Operation::update(std::span<const uint8_t> msg) {
223 m_prefix_used =
true;
224 m_hash->update(m_prefix.data(), m_prefix.size());
229bool ECKCDSA_Verification_Operation::is_valid_signature(std::span<const uint8_t> sig) {
230 m_prefix_used =
false;
231 std::vector<uint8_t> digest = m_hash->final_stdvec();
233 return verify(digest, sig);
236bool ECKCDSA_Verification_Operation::verify(std::span<const uint8_t> msg, std::span<const uint8_t> sig) {
239 const size_t size_r = std::min(msg.size(), order_bytes);
240 if(sig.size() != size_r + order_bytes) {
244 const auto r = sig.first(size_r);
246 if(
auto s = EC_Scalar::deserialize(m_group, sig.last(order_bytes))) {
247 std::vector<uint8_t> r_xor_e(r.size());
248 xor_buf(r_xor_e, r, msg.first(size_r));
250 const auto w = EC_Scalar::from_bytes_mod_order(m_group, r_xor_e);
253 std::vector<uint8_t> v = m_hash->process<std::vector<uint8_t>>(q->x_bytes());
265 return domain().get_order_bytes();
269 return std::make_unique<ECKCDSA_PrivateKey>(rng,
domain());
276 return std::make_unique<ECKCDSA_Verification_Operation>(*
this, options);
281 if(provider ==
"base" || provider.empty()) {
282 return std::make_unique<ECKCDSA_Verification_Operation>(*
this, signature_algorithm);
294 return std::make_unique<ECKCDSA_Signature_Operation>(*
this, options);
bool check_key(RandomNumberGenerator &rng, bool strong) const override
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
std::unique_ptr< PK_Ops::Verification > create_x509_verification_op(const AlgorithmIdentifier &signature_algorithm, std::string_view provider) const override
std::string algo_name() const override
std::unique_ptr< PK_Ops::Verification > _create_verification_op(const PK_Signature_Options_Reader &options) const override
std::optional< size_t > _signature_element_size_for_DER_encoding() const override
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
std::optional< EC_AffinePoint > mul2_vartime(const EC_Scalar &x, const EC_Scalar &y) const
size_t get_order_bytes() const
bool check_key(RandomNumberGenerator &rng, bool strong) const override
const EC_Group & domain() const
const EC_AffinePoint & public_ec_point() const
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
const std::string & hash_function_name() const
bool signature_consistency_check(RandomNumberGenerator &rng, const Private_Key &private_key, const Public_Key &public_key, std::string_view padding)
std::string fmt(std::string_view format, const T &... args)
std::vector< std::string > split_on(std::string_view str, char delim)
void require_software_provider(const OptionsT &options, std::string_view algo_name)
constexpr auto concat(Rs &&... ranges)
constexpr void xor_buf(ranges::contiguous_output_range< uint8_t > auto &&out, ranges::contiguous_range< uint8_t > auto &&in)
bool constant_time_compare(std::span< const uint8_t > x, std::span< const uint8_t > y)