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
|
/*************************************************
* Base Classes Header File *
* (C) 1999-2007 Jack Lloyd *
*************************************************/
#ifndef BOTAN_BASE_H__
#define BOTAN_BASE_H__
#include <botan/exceptn.h>
#include <botan/symkey.h>
namespace Botan {
/*************************************************
* Constants *
*************************************************/
static const u32bit DEFAULT_BUFFERSIZE = BOTAN_DEFAULT_BUFFER_SIZE;
/*************************************************
* Symmetric Algorithm *
*************************************************/
class BOTAN_DLL SymmetricAlgorithm
{
public:
const u32bit MAXIMUM_KEYLENGTH, MINIMUM_KEYLENGTH, KEYLENGTH_MULTIPLE;
virtual std::string name() const = 0;
void set_key(const SymmetricKey&) throw(Invalid_Key_Length);
void set_key(const byte[], u32bit) throw(Invalid_Key_Length);
bool valid_keylength(u32bit) const;
SymmetricAlgorithm(u32bit, u32bit, u32bit);
virtual ~SymmetricAlgorithm() {}
private:
virtual void key(const byte[], u32bit) = 0;
};
/*************************************************
* Block Cipher *
*************************************************/
class BOTAN_DLL BlockCipher : public SymmetricAlgorithm
{
public:
const u32bit BLOCK_SIZE;
void encrypt(const byte in[], byte out[]) const { enc(in, out); }
void decrypt(const byte in[], byte out[]) const { dec(in, out); }
void encrypt(byte block[]) const { enc(block, block); }
void decrypt(byte block[]) const { dec(block, block); }
virtual BlockCipher* clone() const = 0;
virtual void clear() throw() = 0;
BlockCipher(u32bit, u32bit, u32bit = 0, u32bit = 1);
virtual ~BlockCipher() {}
private:
virtual void enc(const byte[], byte[]) const = 0;
virtual void dec(const byte[], byte[]) const = 0;
};
/*************************************************
* Stream Cipher *
*************************************************/
class BOTAN_DLL StreamCipher : public SymmetricAlgorithm
{
public:
const u32bit IV_LENGTH;
void encrypt(const byte i[], byte o[], u32bit len) { cipher(i, o, len); }
void decrypt(const byte i[], byte o[], u32bit len) { cipher(i, o, len); }
void encrypt(byte in[], u32bit len) { cipher(in, in, len); }
void decrypt(byte in[], u32bit len) { cipher(in, in, len); }
virtual void resync(const byte[], u32bit);
virtual void seek(u32bit);
virtual StreamCipher* clone() const = 0;
virtual void clear() throw() = 0;
StreamCipher(u32bit, u32bit = 0, u32bit = 1, u32bit = 0);
virtual ~StreamCipher() {}
private:
virtual void cipher(const byte[], byte[], u32bit) = 0;
};
/*************************************************
* Buffered Computation *
*************************************************/
class BOTAN_DLL BufferedComputation
{
public:
const u32bit OUTPUT_LENGTH;
void update(const byte[], u32bit);
void update(const MemoryRegion<byte>&);
void update(const std::string&);
void update(byte);
void final(byte out[]) { final_result(out); }
SecureVector<byte> final();
SecureVector<byte> process(const byte[], u32bit);
SecureVector<byte> process(const MemoryRegion<byte>&);
SecureVector<byte> process(const std::string&);
BufferedComputation(u32bit);
virtual ~BufferedComputation() {}
private:
BufferedComputation& operator=(const BufferedComputation&);
virtual void add_data(const byte[], u32bit) = 0;
virtual void final_result(byte[]) = 0;
};
/*************************************************
* Hash Function *
*************************************************/
class BOTAN_DLL HashFunction : public BufferedComputation
{
public:
const u32bit HASH_BLOCK_SIZE;
virtual HashFunction* clone() const = 0;
virtual std::string name() const = 0;
virtual void clear() throw() = 0;
HashFunction(u32bit, u32bit = 0);
virtual ~HashFunction() {}
private:
HashFunction& operator=(const HashFunction&);
};
/*************************************************
* Message Authentication Code *
*************************************************/
class BOTAN_DLL MessageAuthenticationCode : public BufferedComputation,
public SymmetricAlgorithm
{
public:
virtual bool verify_mac(const byte[], u32bit);
virtual MessageAuthenticationCode* clone() const = 0;
virtual std::string name() const = 0;
virtual void clear() throw() = 0;
MessageAuthenticationCode(u32bit, u32bit, u32bit = 0, u32bit = 1);
virtual ~MessageAuthenticationCode() {}
};
}
#endif
|
