9#include <botan/p11_ecdsa.h>
11#if defined(BOTAN_HAS_ECDSA)
13 #include <botan/assert.h>
14 #include <botan/p11_mechanism.h>
15 #include <botan/pk_ops.h>
16 #include <botan/pk_options_readers.h>
17 #include <botan/rng.h>
18 #include <botan/internal/keypair.h>
19 #include <botan/internal/p11_object_guard.h>
20 #include <botan/internal/p11_sig_stream.h>
21 #include <botan/internal/pk_options_impl.h>
25ECDSA_PublicKey PKCS11_ECDSA_PublicKey::export_key()
const {
26 return ECDSA_PublicKey(domain(), public_ec_point());
29bool PKCS11_ECDSA_PrivateKey::check_key(RandomNumberGenerator& rng,
bool strong)
const {
34 const ECDSA_PublicKey pubkey(domain(), public_ec_point());
38ECDSA_PrivateKey PKCS11_ECDSA_PrivateKey::export_key()
const {
46 return export_key().private_key_bits();
49std::unique_ptr<Public_Key> PKCS11_ECDSA_PrivateKey::public_key()
const {
50 return std::make_unique<ECDSA_PublicKey>(domain(), public_ec_point());
59std::string p11_ecdsa_mechanism_hash(
const PK_Signature_Options_Reader& options) {
60 if(options.using_externally_computed_prehash()) {
63 return options.hash_function_name();
66std::string p11_ecdsa_hash_name(
const PK_Signature_Options_Reader& options,
const MechanismWrapper& mechanism) {
67 if(options.using_externally_computed_prehash()) {
73 switch(mechanism.mechanism_type()) {
89class PKCS11_ECDSA_Signature_Operation final :
public PK_Ops::Signature {
91 PKCS11_ECDSA_Signature_Operation(
const PKCS11_ECDSA_PrivateKey& key,
const PK_Signature_Options_Reader& options) :
94 m_order_bytes(key.domain().get_order_bytes()),
95 m_mechanism(MechanismWrapper::create_ecdsa_mechanism(p11_ecdsa_mechanism_hash(options))),
96 m_hash(p11_ecdsa_hash_name(options, m_mechanism)),
97 m_stream(Signature_Stream::Direction::
Sign, m_key, m_mechanism) {}
99 void update(std::span<const uint8_t> input)
override { m_stream.update(input); }
101 std::vector<uint8_t> sign(RandomNumberGenerator& )
override {
102 auto signature = m_stream.sign();
103 if(signature.size() != signature_length()) {
104 throw PKCS11_Error(
"PKCS #11 module returned an ECDSA signature of unexpected length");
109 size_t signature_length()
const override {
return 2 * m_order_bytes; }
111 AlgorithmIdentifier algorithm_identifier()
const override;
113 std::string hash_function()
const override {
return m_hash; }
116 const PKCS11_ECDSA_PrivateKey m_key;
117 const size_t m_order_bytes;
118 MechanismWrapper m_mechanism;
119 const std::string m_hash;
120 Signature_Stream m_stream;
123AlgorithmIdentifier PKCS11_ECDSA_Signature_Operation::algorithm_identifier()
const {
124 const std::string full_name =
"ECDSA/" + hash_function();
129class PKCS11_ECDSA_Verification_Operation final :
public PK_Ops::Verification {
131 PKCS11_ECDSA_Verification_Operation(
const PKCS11_ECDSA_PublicKey& key,
132 const PK_Signature_Options_Reader& options) :
133 PK_Ops::Verification(),
135 m_mechanism(MechanismWrapper::create_ecdsa_mechanism(p11_ecdsa_mechanism_hash(options))),
136 m_hash(p11_ecdsa_hash_name(options, m_mechanism)),
137 m_stream(Signature_Stream::Direction::
Verify, m_key, m_mechanism) {}
139 void update(std::span<const uint8_t> input)
override { m_stream.update(input); }
141 bool is_valid_signature(std::span<const uint8_t> sig)
override {
return m_stream.verify(sig); }
143 std::string hash_function()
const override {
return m_hash; }
146 const PKCS11_ECDSA_PublicKey m_key;
147 MechanismWrapper m_mechanism;
148 const std::string m_hash;
149 Signature_Stream m_stream;
154std::unique_ptr<PK_Ops::Verification> PKCS11_ECDSA_PublicKey::_create_verification_op(
155 const PK_Signature_Options_Reader& options)
const {
157 return std::make_unique<PKCS11_ECDSA_Verification_Operation>(*
this, options);
160std::unique_ptr<PK_Ops::Signature> PKCS11_ECDSA_PrivateKey::_create_signature_op(
161 RandomNumberGenerator& rng,
const PK_Signature_Options_Reader& options)
const {
164 return std::make_unique<PKCS11_ECDSA_Signature_Operation>(*
this, options);
167PKCS11_ECDSA_KeyPair generate_ecdsa_keypair(
Session& session,
168 const EC_PublicKeyGenerationProperties& pub_props,
169 const EC_PrivateKeyGenerationProperties& priv_props) {
175 session.module()->C_GenerateKeyPair(session.handle(),
185 PKCS11_ECDSA_PublicKey public_key(session, pub_key_handle);
186 PKCS11_ECDSA_PrivateKey private_key(session, priv_key_handle);
190 const EC_AffinePoint public_point(private_key.domain(), public_key.raw_public_key_bits());
191 private_key.set_public_point(public_point, private_key.point_encoding());
193 return std::make_pair(std::move(public_key), std::move(private_key));
static BigInt from_bytes(std::span< const uint8_t > bytes)
static OID from_string(std::string_view str)
Represents a PKCS#11 session.
bool signature_consistency_check(RandomNumberGenerator &rng, const Private_Key &private_key, const Public_Key &public_key, std::string_view padding)
Ulong checked_ulong_cast(size_t v)
CK_OBJECT_HANDLE ObjectHandle
void require_hardware_provider(const OptionsT &options, std::string_view algo_name, std::string_view provider_name)
std::optional< std::string > externally_computed_prehash_name(const PK_Signature_Options_Reader &options)
std::vector< T, secure_allocator< T > > secure_vector
CK_ULONG CK_MECHANISM_TYPE