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
|
/*
* Stream Cipher
* (C) 1999-2007 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/
#ifndef BOTAN_STREAM_CIPHER_H_
#define BOTAN_STREAM_CIPHER_H_
#include <botan/sym_algo.h>
#include <string>
#include <memory>
namespace Botan {
/**
* Base class for all stream ciphers
*/
class BOTAN_PUBLIC_API(2,0) StreamCipher : public SymmetricAlgorithm
{
public:
virtual ~StreamCipher() = default;
/**
* Create an instance based on a name
* If provider is empty then best available is chosen.
* @param algo_spec algorithm name
* @param provider provider implementation to use
* @return a null pointer if the algo/provider combination cannot be found
*/
static std::unique_ptr<StreamCipher>
create(const std::string& algo_spec,
const std::string& provider = "");
/**
* Create an instance based on a name
* If provider is empty then best available is chosen.
* @param algo_spec algorithm name
* @param provider provider implementation to use
* Throws a Lookup_Error if the algo/provider combination cannot be found
*/
static std::unique_ptr<StreamCipher>
create_or_throw(const std::string& algo_spec,
const std::string& provider = "");
/**
* @return list of available providers for this algorithm, empty if not available
*/
static std::vector<std::string> providers(const std::string& algo_spec);
/**
* Encrypt or decrypt a message
* @param in the plaintext
* @param out the byte array to hold the output, i.e. the ciphertext
* @param len the length of both in and out in bytes
*/
virtual void cipher(const uint8_t in[], uint8_t out[], size_t len) = 0;
/**
* Encrypt or decrypt a message
* The message is encrypted/decrypted in place.
* @param buf the plaintext / ciphertext
* @param len the length of buf in bytes
*/
void cipher1(uint8_t buf[], size_t len)
{ cipher(buf, buf, len); }
/**
* Encrypt a message
* The message is encrypted/decrypted in place.
* @param inout the plaintext / ciphertext
*/
template<typename Alloc>
void encipher(std::vector<uint8_t, Alloc>& inout)
{ cipher(inout.data(), inout.data(), inout.size()); }
/**
* Encrypt a message
* The message is encrypted in place.
* @param inout the plaintext / ciphertext
*/
template<typename Alloc>
void encrypt(std::vector<uint8_t, Alloc>& inout)
{ cipher(inout.data(), inout.data(), inout.size()); }
/**
* Decrypt a message in place
* The message is decrypted in place.
* @param inout the plaintext / ciphertext
*/
template<typename Alloc>
void decrypt(std::vector<uint8_t, Alloc>& inout)
{ cipher(inout.data(), inout.data(), inout.size()); }
/**
* Resync the cipher using the IV
* @param iv the initialization vector
* @param iv_len the length of the IV in bytes
*/
virtual void set_iv(const uint8_t iv[], size_t iv_len) = 0;
/**
* Return the default (preferred) nonce length
* If this function returns 0, then this cipher does not support nonces
*/
virtual size_t default_iv_length() const { return 0; }
/**
* @param iv_len the length of the IV in bytes
* @return if the length is valid for this algorithm
*/
virtual bool valid_iv_length(size_t iv_len) const { return (iv_len == 0); }
/**
* @return a new object representing the same algorithm as *this
*/
virtual StreamCipher* clone() const = 0;
/**
* Set the offset and the state used later to generate the keystream
* @param offset the offset where we begin to generate the keystream
*/
virtual void seek(uint64_t offset) = 0;
/**
* @return provider information about this implementation. Default is "base",
* might also return "sse2", "avx2", "openssl", or some other arbitrary string.
*/
virtual std::string provider() const { return "base"; }
};
}
#endif
|
