blob: b15a8d8cd749317b8c81b81c9e7dee01c25d91a1 (
plain)
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
|
/*
* PK Operation Types
* (C) 2010 Jack Lloyd
*
* Distributed under the terms of the Botan license
*/
#ifndef BOTAN_PK_OPERATIONS_H__
#define BOTAN_PK_OPERATIONS_H__
#include <botan/secmem.h>
#include <botan/rng.h>
namespace Botan {
namespace PK_Ops {
/**
* Public key encryption interface
*/
class BOTAN_DLL Encryption
{
public:
virtual u32bit max_input_bits() const = 0;
virtual SecureVector<byte> encrypt(const byte msg[], u32bit msg_len,
RandomNumberGenerator& rng) = 0;
virtual ~Encryption() {}
};
/**
* Public key decryption interface
*/
class BOTAN_DLL Decryption
{
public:
virtual u32bit max_input_bits() const = 0;
virtual SecureVector<byte> decrypt(const byte msg[],
u32bit msg_len) = 0;
virtual ~Decryption() {}
};
/**
* 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 u32bit message_parts() const { return 1; }
/**
* Find out the message part size supported by this scheme/key.
* @return size of the message parts
*/
virtual u32bit message_part_size() const { return 0; }
/**
* Get the maximum message size in bits supported by this public key.
* @return maximum message in bits
*/
virtual u32bit 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 SecureVector<byte> sign(const byte msg[], u32bit msg_len,
RandomNumberGenerator& rng) = 0;
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 u32bit max_input_bits() const = 0;
/**
* Find out the number of message parts supported by this scheme.
* @return number of message parts
*/
virtual u32bit message_parts() const { return 1; }
/**
* Find out the message part size supported by this scheme/key.
* @return size of the message parts
*/
virtual u32bit 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[], u32bit,
const byte[], u32bit)
{
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 SecureVector<byte> verify_mr(const byte[],
u32bit)
{
throw Invalid_State("Message recovery not supported");
}
virtual ~Verification() {}
};
/**
* A generic key agreement Operation (eg DH or ECDH)
*/
class BOTAN_DLL Key_Agreement
{
public:
/*
* Perform a key agreement operation
* @param w the other key value
* @param w_len the length of w in bytes
* @returns the agreed key
*/
virtual SecureVector<byte> agree(const byte w[], u32bit w_len) = 0;
virtual ~Key_Agreement() {}
};
}
}
#endif
|
