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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/*
* PK Operation Types
* (C) 2010,2015 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/
#ifndef BOTAN_PK_OPERATIONS_H__
#define BOTAN_PK_OPERATIONS_H__
#include <botan/pk_keys.h>
#include <botan/secmem.h>
#include <botan/rng.h>
namespace Botan {
class EME;
class KDF;
class EMSA;
namespace PK_Ops {
template<typename Key>
struct PK_Spec
{
public:
PK_Spec(const Key& key, const std::string& pad) :
m_key(key), m_pad(pad) {}
std::string algo_name() const { return m_key.algo_name(); }
std::string as_string() const { return algo_name() + "/" + padding(); }
const Key& key() const { return m_key; }
const std::string& padding() const { return m_pad; }
private:
const Key& m_key;
const std::string m_pad;
};
/**
* Public key encryption interface
*/
class BOTAN_DLL Encryption
{
public:
virtual size_t max_input_bits() const = 0;
virtual secure_vector<byte> encrypt(const byte msg[], size_t msg_len, RandomNumberGenerator& rng) = 0;
typedef PK_Spec<Public_Key> Spec;
virtual ~Encryption() {}
};
class BOTAN_DLL Encryption_with_EME : public Encryption
{
public:
size_t max_input_bits() const override;
secure_vector<byte> encrypt(const byte msg[], size_t msg_len,
RandomNumberGenerator& rng) override;
~Encryption_with_EME();
protected:
Encryption_with_EME(const std::string& eme);
private:
virtual size_t max_raw_input_bits() const = 0;
virtual secure_vector<byte> raw_encrypt(const byte msg[], size_t len,
RandomNumberGenerator& rng) = 0;
std::unique_ptr<EME> m_eme;
};
/**
* Public key decryption interface
*/
class BOTAN_DLL Decryption
{
public:
virtual size_t max_input_bits() const = 0;
virtual secure_vector<byte> decrypt(const byte msg[], size_t msg_len) = 0;
typedef PK_Spec<Private_Key> Spec;
virtual ~Decryption() {}
};
class BOTAN_DLL Decryption_with_EME : public Decryption
{
public:
size_t max_input_bits() const override;
secure_vector<byte> decrypt(const byte msg[], size_t msg_len) override;
~Decryption_with_EME();
protected:
Decryption_with_EME(const std::string& eme);
private:
virtual size_t max_raw_input_bits() const = 0;
virtual secure_vector<byte> raw_decrypt(const byte msg[], size_t len) = 0;
std::unique_ptr<EME> m_eme;
};
/**
* Public key signature creation interface
*/
class BOTAN_DLL Signature
{
public:
/**
* Find out the number of message parts supported by this scheme.
* @return number of message parts
*/
virtual size_t message_parts() const { return 1; }
/**
* Find out the message part size supported by this scheme/key.
* @return size of the message parts
*/
virtual size_t message_part_size() const { return 0; }
/**
* Get the maximum message size in bits supported by this public key.
* @return maximum message in bits
*/
virtual size_t max_input_bits() const = 0;
/*
* Perform a signature operation
* @param msg the message
* @param msg_len the length of msg in bytes
* @param rng a random number generator
*/
virtual secure_vector<byte> sign(const byte msg[], size_t msg_len,
RandomNumberGenerator& rng) = 0;
typedef PK_Spec<Private_Key> Spec;
virtual ~Signature() {}
};
/**
* Public key signature verification interface
*/
class BOTAN_DLL Verification
{
public:
/**
* Get the maximum message size in bits supported by this public key.
* @return maximum message in bits
*/
virtual size_t max_input_bits() const = 0;
/**
* Find out the number of message parts supported by this scheme.
* @return number of message parts
*/
virtual size_t message_parts() const { return 1; }
/**
* Find out the message part size supported by this scheme/key.
* @return size of the message parts
*/
virtual size_t message_part_size() const { return 0; }
/**
* @return boolean specifying if this key type supports message
* recovery and thus if you need to call verify() or verify_mr()
*/
virtual bool with_recovery() const = 0;
/*
* Perform a signature check operation
* @param msg the message
* @param msg_len the length of msg in bytes
* @param sig the signature
* @param sig_len the length of sig in bytes
* @returns if signature is a valid one for message
*/
virtual bool verify(const byte[], size_t,
const byte[], size_t)
{
throw Invalid_State("Message recovery required");
}
/*
* Perform a signature operation (with message recovery)
* Only call this if with_recovery() returns true
* @param msg the message
* @param msg_len the length of msg in bytes
* @returns recovered message
*/
virtual secure_vector<byte> verify_mr(const byte[],
size_t)
{
throw Invalid_State("Message recovery not supported");
}
typedef PK_Spec<Public_Key> Spec;
virtual ~Verification() {}
};
/**
* A generic key agreement operation (eg DH or ECDH)
*/
class BOTAN_DLL Key_Agreement
{
public:
virtual secure_vector<byte> agree(size_t key_len,
const byte other_key[], size_t other_key_len,
const byte salt[], size_t salt_len) = 0;
typedef PK_Spec<Private_Key> Spec;
virtual ~Key_Agreement() {}
};
class BOTAN_DLL Key_Agreement_with_KDF : public Key_Agreement
{
public:
secure_vector<byte> agree(size_t key_len,
const byte other_key[], size_t other_key_len,
const byte salt[], size_t salt_len) override;
protected:
Key_Agreement_with_KDF(const std::string& kdf);
~Key_Agreement_with_KDF();
private:
virtual secure_vector<byte> raw_agree(const byte w[], size_t w_len) = 0;
std::unique_ptr<KDF> m_kdf;
};
}
}
#endif
|
