1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
/*
* PKCS#11 ECDSA
* (C) 2016 Daniel Neus, Sirrix AG
* (C) 2016 Philipp Weber, Sirrix AG
*
* Botan is released under the Simplified BSD License (see license.txt)
*/
#ifndef BOTAN_P11_ECDSA_H_
#define BOTAN_P11_ECDSA_H_
#include <botan/p11.h>
#include <botan/pk_keys.h>
#if defined(BOTAN_HAS_ECDSA)
#include <botan/p11_ecc_key.h>
#include <botan/ecdsa.h>
#include <string>
namespace Botan {
namespace PKCS11 {
class Session;
/// Represents a PKCS#11 ECDSA public key
class BOTAN_PUBLIC_API(2,0) PKCS11_ECDSA_PublicKey final : public PKCS11_EC_PublicKey, public virtual ECDSA_PublicKey
{
public:
/**
* Creates a PKCS11_ECDSA_PublicKey object from an existing PKCS#11 ECDSA public key
* @param session the session to use
* @param handle the handle of the ECDSA public key
*/
PKCS11_ECDSA_PublicKey(Session& session, ObjectHandle handle)
: EC_PublicKey(), PKCS11_EC_PublicKey(session, handle)
{}
/**
* Imports an ECDSA public key
* @param session the session to use
* @param props the attributes of the public key
*/
PKCS11_ECDSA_PublicKey(Session& session, const EC_PublicKeyImportProperties& props)
: EC_PublicKey(), PKCS11_EC_PublicKey(session, props)
{}
inline std::string algo_name() const override
{
return "ECDSA";
}
/// @return the exported ECDSA public key
ECDSA_PublicKey export_key() const;
std::unique_ptr<PK_Ops::Verification>
create_verification_op(const std::string& params,
const std::string& provider) const override;
};
/// Represents a PKCS#11 ECDSA private key
class BOTAN_PUBLIC_API(2,0) PKCS11_ECDSA_PrivateKey final : public PKCS11_EC_PrivateKey
{
public:
/**
* Creates a PKCS11_ECDSA_PrivateKey object from an existing PKCS#11 ECDSA private key
* @param session the session to use
* @param handle the handle of the ECDSA private key
*/
PKCS11_ECDSA_PrivateKey(Session& session, ObjectHandle handle)
: PKCS11_EC_PrivateKey(session, handle)
{}
/**
* Imports a ECDSA private key
* @param session the session to use
* @param props the attributes of the private key
*/
PKCS11_ECDSA_PrivateKey(Session& session, const EC_PrivateKeyImportProperties& props)
: PKCS11_EC_PrivateKey(session, props)
{}
/**
* Generates a PKCS#11 ECDSA private key
* @param session the session to use
* @param ec_params DER-encoding of an ANSI X9.62 Parameters value
* @param props the attributes of the private key
* @note no persistent public key object will be created
*/
PKCS11_ECDSA_PrivateKey(Session& session, const std::vector<uint8_t>& ec_params,
const EC_PrivateKeyGenerationProperties& props)
: PKCS11_EC_PrivateKey(session, ec_params, props)
{}
inline std::string algo_name() const override
{
return "ECDSA";
}
size_t message_parts() const override { return 2; }
size_t message_part_size() const override
{ return domain().get_order().bytes(); }
/// @return the exported ECDSA private key
ECDSA_PrivateKey export_key() const;
secure_vector<uint8_t> private_key_bits() const override;
bool check_key(RandomNumberGenerator&, bool) const override;
std::unique_ptr<PK_Ops::Signature>
create_signature_op(RandomNumberGenerator& rng,
const std::string& params,
const std::string& provider) const override;
};
using PKCS11_ECDSA_KeyPair = std::pair<PKCS11_ECDSA_PublicKey, PKCS11_ECDSA_PrivateKey>;
/**
* ECDSA key pair generation
* @param session the session that should be used for the key generation
* @param pub_props the properties of the public key
* @param priv_props the properties of the private key
*/
BOTAN_PUBLIC_API(2,0) PKCS11_ECDSA_KeyPair generate_ecdsa_keypair(Session& session,
const EC_PublicKeyGenerationProperties& pub_props, const EC_PrivateKeyGenerationProperties& priv_props);
}
}
#endif
#endif
|
