9#include <botan/ed448.h>
11#include <botan/ber_dec.h>
12#include <botan/der_enc.h>
13#include <botan/hash.h>
14#include <botan/pk_options_readers.h>
16#include <botan/internal/ct_utils.h>
17#include <botan/internal/ed448_internal.h>
18#include <botan/internal/pk_ops_impl.h>
19#include <botan/internal/pk_options_impl.h>
25class Ed448_PublicKey_Data final {
27 explicit Ed448_PublicKey_Data(std::array<uint8_t, ED448_LEN> key) : m_key(key) {}
29 const std::array<uint8_t, ED448_LEN>& key()
const {
return m_key; }
32 std::array<uint8_t, ED448_LEN> m_key;
35class Ed448_PrivateKey_Data final {
46 const auto& sk = m_private->key();
47 return {sk.begin(), sk.end()};
63 throw Decoding_Error(
"Unexpected parameters for Ed448 public key");
71 std::array<uint8_t, ED448_LEN> pub{};
78 m_public = std::make_shared<const Ed448_PublicKey_Data>(pub);
83 return {pub.begin(), pub.end()};
91 return std::make_unique<Ed448_PrivateKey>(rng);
97 throw Decoding_Error(
"Unexpected parameters for Ed448 private key");
107 m_public = std::make_shared<const Ed448_PublicKey_Data>(pub);
108 m_private = std::make_shared<const Ed448_PrivateKey_Data>(std::move(bits));
118 std::array<uint8_t, ED448_LEN> pub{};
124 m_public = std::make_shared<const Ed448_PublicKey_Data>(pub);
125 m_private = std::make_shared<const Ed448_PrivateKey_Data>(std::move(sk));
133 const auto& sk = m_private->key();
139 const auto& sk = m_private->key();
144 return public_point ==
m_public->key();
152 virtual void update(std::span<const uint8_t> msg) = 0;
153 virtual std::vector<uint8_t> get_and_clear() = 0;
155 Ed448_Message() =
default;
156 virtual ~Ed448_Message() =
default;
157 Ed448_Message(
const Ed448_Message&) =
delete;
158 Ed448_Message& operator=(
const Ed448_Message&) =
delete;
159 Ed448_Message(Ed448_Message&&) =
delete;
160 Ed448_Message& operator=(Ed448_Message&&) =
delete;
163class Prehashed_Ed448_Message final :
public Ed448_Message {
165 void update(std::span<const uint8_t> msg)
override { m_hash->update(msg); }
167 std::vector<uint8_t> get_and_clear()
override {
return m_hash->final_stdvec(); }
169 explicit Prehashed_Ed448_Message(std::string_view hash) : m_hash(HashFunction::create_or_throw(hash)) {}
172 std::unique_ptr<HashFunction> m_hash;
175class Pure_Ed448_Message final :
public Ed448_Message {
177 void update(std::span<const uint8_t> msg)
override { m_msg.insert(m_msg.end(), msg.begin(), msg.end()); }
179 std::vector<uint8_t> get_and_clear()
override {
return std::exchange(m_msg, {}); }
182 std::vector<uint8_t> m_msg;
190 explicit Ed448_Verify_Operation(std::shared_ptr<const Ed448_PublicKey_Data> public_key,
191 std::optional<std::string> prehash_function = std::nullopt) :
192 m_public_key(std::move(public_key)), m_prehash_function(std::move(prehash_function)) {
193 if(m_prehash_function) {
194 m_message = std::make_unique<Prehashed_Ed448_Message>(*m_prehash_function);
196 m_message = std::make_unique<Pure_Ed448_Message>();
200 void update(std::span<const uint8_t> input)
override { m_message->update(input); }
202 bool is_valid_signature(std::span<const uint8_t> sig)
override {
203 const auto msg = m_message->get_and_clear();
206 std::span(m_public_key->key()).first<
ED448_LEN>(), m_prehash_function.has_value(), {}, sig, msg);
207 }
catch(Decoding_Error&) {
212 std::string hash_function()
const override {
return m_prehash_function.value_or(
"SHAKE-256(912)"); }
215 std::shared_ptr<const Ed448_PublicKey_Data> m_public_key;
216 std::unique_ptr<Ed448_Message> m_message;
217 std::optional<std::string> m_prehash_function;
225 Ed448_Sign_Operation(std::shared_ptr<const Ed448_PublicKey_Data> public_key,
226 std::shared_ptr<const Ed448_PrivateKey_Data> private_key,
227 std::optional<std::string> prehash_function = std::nullopt) :
228 m_public_key(std::move(public_key)),
229 m_private_key(std::move(private_key)),
230 m_prehash_function(std::move(prehash_function)) {
231 if(m_prehash_function) {
232 m_message = std::make_unique<Prehashed_Ed448_Message>(*m_prehash_function);
234 m_message = std::make_unique<Pure_Ed448_Message>();
238 void update(std::span<const uint8_t> input)
override { m_message->update(input); }
240 std::vector<uint8_t> sign(RandomNumberGenerator& )
override {
241 const auto& sk = m_private_key->key();
244 const auto sig =
sign_message(std::span(sk).first<ED448_LEN>(),
245 std::span(m_public_key->key()).first<
ED448_LEN>(),
246 m_prehash_function.has_value(),
248 m_message->get_and_clear());
250 return {sig.begin(), sig.end()};
253 size_t signature_length()
const override {
return 2 *
ED448_LEN; }
255 AlgorithmIdentifier algorithm_identifier()
const override;
257 std::string hash_function()
const override {
return m_prehash_function.value_or(
"SHAKE-256(912)"); }
260 std::shared_ptr<const Ed448_PublicKey_Data> m_public_key;
261 std::shared_ptr<const Ed448_PrivateKey_Data> m_private_key;
262 std::unique_ptr<Ed448_Message> m_message;
263 std::optional<std::string> m_prehash_function;
269 if(m_prehash_function) {
270 throw Not_Implemented(
"Ed448ph signatures do not have an algorithm identifier");
272 return AlgorithmIdentifier(OID::from_string(
"Ed448"), AlgorithmIdentifier::USE_EMPTY_PARAM);
284 return std::make_unique<Ed448_Verify_Operation>(
m_public);
289 std::string_view provider)
const {
290 if(provider ==
"base" || provider.empty()) {
292 throw Decoding_Error(
"Unexpected AlgorithmIdentifier for Ed448 X509 signature");
295 return std::make_unique<Ed448_Verify_Operation>(
m_public);
309 return std::make_unique<Ed448_Sign_Operation>(
312 return std::make_unique<Ed448_Sign_Operation>(
m_public, m_private);
#define BOTAN_ASSERT_NOMSG(expr)
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)
Ed448_PrivateKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &options) const override
bool check_key(RandomNumberGenerator &rng, bool strong) const override
secure_vector< uint8_t > raw_private_key_bits() const override
secure_vector< uint8_t > private_key_bits() const override
std::unique_ptr< Public_Key > public_key() const override
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< Private_Key > generate_another(RandomNumberGenerator &rng) const final
std::vector< uint8_t > public_key_bits() const override
std::shared_ptr< const Ed448_PublicKey_Data > m_public
Ed448_PublicKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
friend class Ed448_PrivateKey
std::unique_ptr< PK_Ops::Verification > create_x509_verification_op(const AlgorithmIdentifier &signature_algorithm, std::string_view provider) const override
Ed448_PublicKey()=default
bool check_key(RandomNumberGenerator &rng, bool strong) const override
std::vector< uint8_t > raw_public_key_bits() const override
const std::optional< std::string > & prehash_function() const
bool using_prehash() const
constexpr auto scoped_poison(const Ts &... xs)
constexpr void unpoison(const T *p, size_t n)
void ed448_validate_public_key_point(std::span< const uint8_t, ED448_LEN > pk)
void acknowledge_always_deterministic(const PK_Signature_Options_Reader &options)
std::array< uint8_t, ED448_LEN > create_pk_from_sk(std::span< const uint8_t, ED448_LEN > sk)
Create a public key point from a secret key (RFC 8032 5.2.5).
constexpr size_t ED448_LEN
constexpr void copy_mem(T *out, const T *in, 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).
std::vector< T, secure_allocator< T > > secure_vector
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).