9#include <botan/ed25519.h>
11#include <botan/ber_dec.h>
12#include <botan/der_enc.h>
13#include <botan/hash.h>
14#include <botan/mem_ops.h>
15#include <botan/pk_options_readers.h>
16#include <botan/pubkey.h>
18#include <botan/internal/ct_utils.h>
19#include <botan/internal/ed25519_internal.h>
20#include <botan/internal/pk_ops_impl.h>
21#include <botan/internal/pk_options_impl.h>
26class Ed25519_PublicKey_Data final {
28 explicit Ed25519_PublicKey_Data(std::vector<uint8_t> key) : m_key(std::move(key)) {}
30 const std::vector<uint8_t>& key()
const {
return m_key; }
33 std::vector<uint8_t> m_key;
36class Ed25519_PrivateKey_Data final {
51 return m_private->key();
55 return m_private->key();
69std::shared_ptr<const Ed25519_PublicKey_Data> load_ed25519_public_key(std::span<const uint8_t> key_bits) {
70 if(key_bits.size() != 32) {
77 throw Decoding_Error(
"Invalid Ed25519 public key");
80 return std::make_shared<const Ed25519_PublicKey_Data>(std::vector<uint8_t>(key_bits.begin(), key_bits.end()));
86 m_public = load_ed25519_public_key(std::span<const uint8_t>{pub_key, pub_len});
92 throw Decoding_Error(
"Unexpected parameters for Ed25519 public key");
95 m_public = load_ed25519_public_key(key_bits);
107 return std::make_unique<Ed25519_PrivateKey>(rng);
115 std::shared_ptr<const Ed25519_PublicKey_Data>& pk_out,
116 std::shared_ptr<const Ed25519_PrivateKey_Data>& sk_out) {
118 pk_out = std::make_shared<const Ed25519_PublicKey_Data>(
119 std::vector<uint8_t>(expanded_key.begin() + 32, expanded_key.end()));
120 sk_out = std::make_shared<const Ed25519_PrivateKey_Data>(std::move(expanded_key));
127Ed25519_Scalar ed25519_secret_scalar(HashFunction& sha512, std::span<const uint8_t> seed) {
128 std::array<uint8_t, 64> az{};
145 copy_mem(sk.data(), seed.data(), 32);
146 const auto sk_seed = std::span{sk}.first<32>();
150 const auto a = ed25519_secret_scalar(*sha512, sk_seed);
160 if(secret_key.size() == 64) {
164 auto expanded = ed25519_expand_seed(secret_key.first(32));
165 if(!
CT::is_equal(expanded.data() + 32, secret_key.data() + 32, 32).as_bool()) {
166 throw Decoding_Error(
"Ed25519 public key does not match the private key");
168 load_ed25519_keypair(std::move(expanded),
m_public, m_private);
169 }
else if(secret_key.size() == 32) {
170 load_ed25519_keypair(ed25519_expand_seed(secret_key),
m_public, m_private);
178 if(seed.size() != 32) {
179 throw Decoding_Error(
"Ed25519 seed must be exactly 32 bytes long");
186 if(bytes.size() != 64) {
187 throw Decoding_Error(
"Ed25519 private key must be exactly 64 bytes long");
194 load_ed25519_keypair(ed25519_expand_seed(seed),
m_public, m_private);
200 throw Decoding_Error(
"Unexpected parameters for Ed25519 private key");
206 if(bits.size() != 32) {
209 load_ed25519_keypair(ed25519_expand_seed(bits),
m_public, m_private);
217 const auto& priv = m_private->key();
223 const auto& priv = m_private->key();
224 const auto regen = ed25519_expand_seed(std::span<const uint8_t>{priv.data(), 32});
226 return std::vector<uint8_t>(regen.begin() + 32, regen.end()) ==
m_public->key();
235std::vector<uint8_t> ed25519ph_domain_sep() {
236 constexpr std::string_view prefix =
"SigEd25519 no Ed25519 collisions";
237 std::vector<uint8_t> ds(prefix.begin(), prefix.end());
249class Ed25519_Verify_Operation_Base :
public PK_Ops::Verification {
251 Ed25519_Verify_Operation_Base(std::shared_ptr<const Ed25519_PublicKey_Data> key,
252 std::vector<uint8_t> domain_sep) :
253 m_key(std::move(key)), m_domain_sep(std::move(domain_sep)) {
257 bool verify_signature(std::span<const uint8_t> msg, std::span<const uint8_t, 64> sig)
const {
258 const auto& pk = m_key->key();
267 std::array<uint8_t, 64> hram{};
270 sha512->update(m_domain_sep);
271 sha512->update(sig.data(), 32);
282 std::shared_ptr<const Ed25519_PublicKey_Data> m_key;
283 std::vector<uint8_t> m_domain_sep;
289class Ed25519_Pure_Verify_Operation final :
public Ed25519_Verify_Operation_Base {
291 explicit Ed25519_Pure_Verify_Operation(std::shared_ptr<const Ed25519_PublicKey_Data> key,
292 std::vector<uint8_t> domain_sep = {}) :
293 Ed25519_Verify_Operation_Base(std::move(key), std::move(domain_sep)) {}
295 void update(std::span<const uint8_t> msg)
override { m_msg.insert(m_msg.end(), msg.begin(), msg.end()); }
297 bool is_valid_signature(std::span<const uint8_t> sig)
override {
298 if(sig.size() != 64) {
308 std::string hash_function()
const override {
return "SHA-512"; }
311 std::vector<uint8_t> m_msg;
317class Ed25519_Hashed_Verify_Operation final :
public Ed25519_Verify_Operation_Base {
319 Ed25519_Hashed_Verify_Operation(std::shared_ptr<const Ed25519_PublicKey_Data> key,
320 std::string_view hash,
322 Ed25519_Verify_Operation_Base(std::move(key), rfc8032 ? ed25519ph_domain_sep() : std::vector<uint8_t>{}),
325 void update(std::span<const uint8_t> msg)
override { m_hash->update(msg); }
327 bool is_valid_signature(std::span<const uint8_t> sig)
override {
328 std::vector<uint8_t> msg_hash(m_hash->output_length());
329 m_hash->final(msg_hash.data());
331 if(sig.size() != 64) {
338 std::string hash_function()
const override {
return m_hash->name(); }
341 std::unique_ptr<HashFunction> m_hash;
352 size_t signature_length()
const override {
return 64; }
355 Ed25519_Sign_Operation_Base(std::shared_ptr<const Ed25519_PrivateKey_Data> key, std::vector<uint8_t> domain_sep) :
356 m_key(std::move(key)), m_domain_sep(std::move(domain_sep)) {
360 std::vector<uint8_t>
sign_message(std::span<const uint8_t> msg)
const {
361 const auto& sk = m_key->key();
362 const auto seed = std::span{sk}.first<32>();
365 std::vector<uint8_t> sig_buf(64);
366 const std::span<uint8_t, 64> sig(sig_buf.data(), 64);
368 std::array<uint8_t, 64> hram{};
372 sha512->update(sk.data(), 32);
373 std::array<uint8_t, 64> az{};
381 std::array<uint8_t, 64> nonce{};
382 sha512->update(m_domain_sep);
383 sha512->update(std::span{az}.last(32));
385 sha512->final(nonce);
390 sha512->update(m_domain_sep);
391 sha512->update(sig.first(32));
392 sha512->update(sk.data() + 32, 32);
398 const auto s = h * a + r;
399 s.serialize_to(sig.last<32>());
409 std::shared_ptr<const Ed25519_PrivateKey_Data> m_key;
410 std::vector<uint8_t> m_domain_sep;
416class Ed25519_Pure_Sign_Operation final :
public Ed25519_Sign_Operation_Base {
418 explicit Ed25519_Pure_Sign_Operation(std::shared_ptr<const Ed25519_PrivateKey_Data> key,
419 std::vector<uint8_t> domain_sep = {}) :
420 Ed25519_Sign_Operation_Base(std::move(key), std::move(domain_sep)) {}
422 void update(std::span<const uint8_t> msg)
override { m_msg.insert(m_msg.end(), msg.begin(), msg.end()); }
424 std::vector<uint8_t> sign(RandomNumberGenerator& )
override {
430 AlgorithmIdentifier algorithm_identifier()
const override;
432 std::string hash_function()
const override {
return "SHA-512"; }
435 std::vector<uint8_t> m_msg;
439 return AlgorithmIdentifier(OID::from_string(
"Ed25519"), AlgorithmIdentifier::USE_EMPTY_PARAM);
445class Ed25519_Hashed_Sign_Operation final :
public Ed25519_Sign_Operation_Base {
447 Ed25519_Hashed_Sign_Operation(std::shared_ptr<const Ed25519_PrivateKey_Data> key,
448 std::string_view hash,
450 Ed25519_Sign_Operation_Base(std::move(key), rfc8032 ? ed25519ph_domain_sep() : std::vector<uint8_t>{}),
451 m_hash(HashFunction::create_or_throw(hash)) {}
453 void update(std::span<const uint8_t> msg)
override { m_hash->update(msg); }
455 std::vector<uint8_t> sign(RandomNumberGenerator& )
override {
456 std::vector<uint8_t> msg_hash(m_hash->output_length());
457 m_hash->final(msg_hash.data());
461 std::string hash_function()
const override {
return m_hash->name(); }
464 std::unique_ptr<HashFunction> m_hash;
477 return std::make_unique<Ed25519_Hashed_Verify_Operation>(
m_public,
"SHA-512",
true);
480 return std::make_unique<Ed25519_Pure_Verify_Operation>(
m_public);
485 std::string_view provider)
const {
486 if(provider ==
"base" || provider.empty()) {
488 throw Decoding_Error(
"Unexpected AlgorithmIdentifier for Ed25519 X509 signature");
491 return std::make_unique<Ed25519_Pure_Verify_Operation>(
m_public);
506 return std::make_unique<Ed25519_Hashed_Sign_Operation>(m_private, options.
prehash_function().value(),
false);
508 return std::make_unique<Ed25519_Hashed_Sign_Operation>(m_private,
"SHA-512",
true);
511 return std::make_unique<Ed25519_Pure_Sign_Operation>(m_private);
525 const auto priv_bytes = key.raw_private_key_bits();
527 copy_mem(sk, priv_bytes.data(), 64);
533 const uint8_t sk[64],
534 const uint8_t domain_sep[],
535 size_t domain_sep_len) {
540 std::vector<uint8_t> sig_vec;
541 if(domain_sep_len == 0) {
543 signer.
update(std::span<const uint8_t>{msg, msg_len});
546 Ed25519_Pure_Sign_Operation op(std::make_shared<Ed25519_PrivateKey_Data>(key.raw_private_key_bits()),
547 std::vector<uint8_t>(domain_sep, domain_sep + domain_sep_len));
548 op.update(std::span<const uint8_t>{msg, msg_len});
549 sig_vec = op.sign(null_rng);
557 const uint8_t sig[64],
558 const uint8_t pk[32],
559 const uint8_t domain_sep[],
560 size_t domain_sep_len) {
564 if(domain_sep_len == 0) {
566 verifier.
update(std::span<const uint8_t>{msg, msg_len});
569 Ed25519_Pure_Verify_Operation op(std::make_shared<Ed25519_PublicKey_Data>(key.raw_public_key_bits()),
570 std::vector<uint8_t>(domain_sep, domain_sep + domain_sep_len));
571 op.update(std::span<const uint8_t>{msg, msg_len});
572 return op.is_valid_signature(std::span<const uint8_t>{sig, 64});
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_ASSERT_EQUAL(expr1, expr2, assertion_made)
bool parameters_are_empty() const
virtual OID object_identifier() const
BER_Decoder & decode(bool &out)
BER_Decoder & verify_end()
secure_vector< uint8_t > get_contents()
DER_Encoder & encode(bool b)
Ed25519_PrivateKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
const secure_vector< uint8_t > & get_private_key() const
static Ed25519_PrivateKey from_seed(std::span< const uint8_t > seed)
std::unique_ptr< Public_Key > public_key() const override
bool check_key(RandomNumberGenerator &rng, bool strong) const override
static Ed25519_PrivateKey from_bytes(std::span< const uint8_t > bytes)
secure_vector< uint8_t > raw_private_key_bits() const override
std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &option) const override
secure_vector< uint8_t > private_key_bits() const override
std::shared_ptr< const Ed25519_PublicKey_Data > m_public
std::unique_ptr< PK_Ops::Verification > create_x509_verification_op(const AlgorithmIdentifier &signature_algorithm, std::string_view provider) const override
const std::vector< uint8_t > & get_public_key() const
bool check_key(RandomNumberGenerator &rng, bool strong) const override
std::string algo_name() const override
friend class Ed25519_PrivateKey
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
Ed25519_PublicKey()=default
std::vector< uint8_t > public_key_bits() const override
std::unique_ptr< PK_Ops::Verification > _create_verification_op(const PK_Signature_Options_Reader &options) const override
AlgorithmIdentifier algorithm_identifier() const override
std::vector< uint8_t > raw_public_key_bits() const override
static Ed25519_Scalar from_wide_bytes(std::span< const uint8_t, 2 *BYTES > b)
static std::optional< Ed25519_Scalar > from_canonical_bytes(std::span< const uint8_t, BYTES > b)
static Ed25519_Scalar from_bytes(std::span< const uint8_t, BYTES > b)
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
const std::optional< std::string > & prehash_function() const
bool using_prehash() const
std::vector< uint8_t > signature(RandomNumberGenerator &rng)
bool check_signature(const uint8_t sig[], size_t length)
void random_vec(std::span< uint8_t > v)
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(const T *p, size_t n)
constexpr void poison(const T *p, size_t n)
void ed25519_sign(uint8_t sig[64], const uint8_t msg[], size_t msg_len, const uint8_t sk[64], const uint8_t domain_sep[], size_t domain_sep_len)
bool ed25519_valid_public_key_point(std::span< const uint8_t, 32 > pk)
void acknowledge_always_deterministic(const PK_Signature_Options_Reader &options)
bool ed25519_check_signature(std::span< const uint8_t, 32 > pk, const Ed25519_Scalar &h, const uint8_t r[32], const Ed25519_Scalar &s)
constexpr void copy_mem(T *out, const T *in, size_t n)
void secure_scrub_memory(void *ptr, size_t n)
void require_software_provider(const OptionsT &options, std::string_view algo_name)
bool verify_signature(std::span< const uint8_t, ED448_LEN > pk, bool phflag, std::span< const uint8_t > context, std::span< const uint8_t > sig, std::span< const uint8_t > msg)
Verify a signature(RFC 8032 5.2.7).
void ed25519_gen_keypair(uint8_t pk[32], uint8_t sk[64], const uint8_t seed[32])
std::vector< T, secure_allocator< T > > secure_vector
bool ed25519_verify(const uint8_t msg[], size_t msg_len, const uint8_t sig[64], const uint8_t pk[32], const uint8_t domain_sep[], size_t domain_sep_len)
void ed25519_basepoint_mul(std::span< uint8_t, 32 > out, const Ed25519_Scalar &scalar)
std::array< uint8_t, 2 *ED448_LEN > sign_message(std::span< const uint8_t, ED448_LEN > sk, std::span< const uint8_t, ED448_LEN > pk, bool pgflag, std::span< const uint8_t > context, std::span< const uint8_t > msg)
Sign a message using a keypair (RFC 8032 5.2.6).