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
|
/*
* 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 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 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
|
