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
|
/*
* Engine
* (C) 1999-2007 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/
#ifndef BOTAN_ENGINE_H__
#define BOTAN_ENGINE_H__
#include <botan/scan_name.h>
#include <botan/block_cipher.h>
#include <botan/stream_cipher.h>
#include <botan/hash.h>
#include <botan/mac.h>
#include <botan/pbkdf.h>
#include <botan/pow_mod.h>
#include <botan/pk_keys.h>
#include <botan/pk_ops.h>
namespace Botan {
class Algorithm_Factory;
class Keyed_Filter;
class RandomNumberGenerator;
/**
* Base class for all engines. All non-pure virtual functions simply
* return NULL, indicating the algorithm in question is not
* supported. Subclasses can reimplement whichever function(s)
* they want to hook in a particular type.
*/
class BOTAN_DLL Engine
{
public:
virtual ~Engine() {}
/**
* @return name of this engine
*/
virtual std::string provider_name() const = 0;
/**
* @param algo_spec the algorithm name/specification
* @param af an algorithm factory object
* @return newly allocated object, or NULL
*/
virtual BlockCipher*
find_block_cipher(const SCAN_Name& algo_spec,
Algorithm_Factory& af) const;
/**
* @param algo_spec the algorithm name/specification
* @param af an algorithm factory object
* @return newly allocated object, or NULL
*/
virtual StreamCipher*
find_stream_cipher(const SCAN_Name& algo_spec,
Algorithm_Factory& af) const;
/**
* @param algo_spec the algorithm name/specification
* @param af an algorithm factory object
* @return newly allocated object, or NULL
*/
virtual HashFunction*
find_hash(const SCAN_Name& algo_spec,
Algorithm_Factory& af) const;
/**
* @param algo_spec the algorithm name/specification
* @param af an algorithm factory object
* @return newly allocated object, or NULL
*/
virtual MessageAuthenticationCode*
find_mac(const SCAN_Name& algo_spec,
Algorithm_Factory& af) const;
/**
* @param algo_spec the algorithm name/specification
* @param af an algorithm factory object
* @return newly allocated object, or NULL
*/
virtual PBKDF* find_pbkdf(const SCAN_Name& algo_spec,
Algorithm_Factory& af) const;
/**
* @param n the modulus
* @param hints any use hints
* @return newly allocated object, or NULL
*/
virtual Modular_Exponentiator*
mod_exp(const BigInt& n,
Power_Mod::Usage_Hints hints) const;
/**
* Return a new cipher object
* @param algo_spec the algorithm name/specification
* @param dir specifies if encryption or decryption is desired
* @param af an algorithm factory object
* @return newly allocated object, or NULL
*/
virtual Keyed_Filter* get_cipher(const std::string& algo_spec,
Cipher_Dir dir,
Algorithm_Factory& af);
/**
* Return a new operator object for this key, if possible
* @param key the key we want an operator for
* @return newly allocated operator object, or NULL
*/
virtual PK_Ops::Key_Agreement*
get_key_agreement_op(const Private_Key& key, RandomNumberGenerator& rng) const;
/**
* Return a new operator object for this key, if possible
* @param key the key we want an operator for
* @return newly allocated operator object, or NULL
*/
virtual PK_Ops::Signature*
get_signature_op(const Private_Key& key, const std::string& hash, RandomNumberGenerator& rng) const;
/**
* Return a new operator object for this key, if possible
* @param key the key we want an operator for
* @return newly allocated operator object, or NULL
*/
virtual PK_Ops::Verification*
get_verify_op(const Public_Key& key, const std::string& hash, RandomNumberGenerator& rng) const;
/**
* Return a new operator object for this key, if possible
* @param key the key we want an operator for
* @return newly allocated operator object, or NULL
*/
virtual PK_Ops::Encryption*
get_encryption_op(const Public_Key& key, RandomNumberGenerator& rng) const;
/**
* Return a new operator object for this key, if possible
* @param key the key we want an operator for
* @return newly allocated operator object, or NULL
*/
virtual PK_Ops::Decryption*
get_decryption_op(const Private_Key& key, RandomNumberGenerator& rng) const;
};
}
#endif
|
