monotone

monotone Mtn Source Tree

Root/botan/base.cpp

1/*************************************************
2* Base Classes Source File *
3* (C) 1999-2005 The Botan Project *
4*************************************************/
5
6#include <botan/base.h>
7#include <botan/version.h>
8#include <botan/parsing.h>
9
10namespace Botan {
11
12/*************************************************
13* SymmetricAlgorithm Constructor *
14*************************************************/
15SymmetricAlgorithm::SymmetricAlgorithm(u32bit key_min, u32bit key_max,
16 u32bit key_mod) :
17 MAXIMUM_KEYLENGTH(key_max ? key_max : key_min),
18 MINIMUM_KEYLENGTH(key_min),
19 KEYLENGTH_MULTIPLE(key_mod)
20 {
21 }
22
23/*************************************************
24* Query if the keylength is valid *
25*************************************************/
26bool SymmetricAlgorithm::valid_keylength(u32bit length) const
27 {
28 return ((length >= MINIMUM_KEYLENGTH) &&
29 (length <= MAXIMUM_KEYLENGTH) &&
30 (length % KEYLENGTH_MULTIPLE == 0));
31 }
32
33/*************************************************
34* Set the key *
35*************************************************/
36void SymmetricAlgorithm::set_key(const SymmetricKey& algo_key)
37 throw(Invalid_Key_Length)
38 {
39 set_key(algo_key.begin(), algo_key.length());
40 }
41
42/*************************************************
43* Set the key *
44*************************************************/
45void SymmetricAlgorithm::set_key(const byte algo_key[], u32bit length)
46 throw(Invalid_Key_Length)
47 {
48 if(!valid_keylength(length))
49 throw Invalid_Key_Length(name(), length);
50 key(algo_key, length);
51 }
52
53/*************************************************
54* BlockCipher Constructor *
55*************************************************/
56BlockCipher::BlockCipher(u32bit block, u32bit key_min, u32bit key_max,
57 u32bit key_mod) :
58 SymmetricAlgorithm(key_min, key_max, key_mod),
59 BLOCK_SIZE(block)
60 {
61 }
62
63/*************************************************
64* StreamCipher Constructor *
65*************************************************/
66StreamCipher::StreamCipher(u32bit key_min, u32bit key_max, u32bit key_mod,
67 u32bit iv_len) :
68 SymmetricAlgorithm(key_min, key_max, key_mod), IV_LENGTH(iv_len)
69 {
70 }
71
72/*************************************************
73* BufferedComputation Constructor *
74*************************************************/
75BufferedComputation::BufferedComputation(u32bit olen) : OUTPUT_LENGTH(olen)
76 {
77 }
78
79/*************************************************
80* HashFunction Constructor *
81*************************************************/
82HashFunction::HashFunction(u32bit hlen, u32bit blen) :
83 BufferedComputation(hlen), HASH_BLOCK_SIZE(blen)
84 {
85 }
86
87/*************************************************
88* MessageAuthenticationCode Constructor *
89*************************************************/
90MessageAuthenticationCode::MessageAuthenticationCode(u32bit mlen,
91 u32bit key_min,
92 u32bit key_max,
93 u32bit key_mod) :
94 BufferedComputation(mlen),
95 SymmetricAlgorithm(key_min, key_max, key_mod)
96 {
97 }
98
99/*************************************************
100* Default MAC verification operation *
101*************************************************/
102bool MessageAuthenticationCode::verify_mac(const byte mac[], u32bit length)
103 {
104 SecureVector<byte> our_mac = final();
105 if(our_mac.size() != length)
106 return false;
107 for(u32bit j = 0; j != length; j++)
108 if(mac[j] != our_mac[j])
109 return false;
110 return true;
111 }
112
113/*************************************************
114* Default StreamCipher Resync Operation *
115*************************************************/
116void StreamCipher::resync(const byte[], u32bit length)
117 {
118 if(length)
119 throw Exception("The stream cipher " + name() +
120 " does not support resyncronization");
121 }
122
123/*************************************************
124* Default StreamCipher Seek Operation *
125*************************************************/
126void StreamCipher::seek(u32bit)
127 {
128 throw Exception("The stream cipher " + name() + " does not support seek()");
129 }
130
131/*************************************************
132* Hashing/MACing *
133*************************************************/
134void BufferedComputation::update(const byte in[], u32bit n)
135 {
136 add_data(in, n);
137 }
138
139/*************************************************
140* Hashing/MACing *
141*************************************************/
142void BufferedComputation::update(const MemoryRegion<byte>& in)
143 {
144 add_data(in, in.size());
145 }
146
147/*************************************************
148* Hashing/MACing *
149*************************************************/
150void BufferedComputation::update(const std::string& str)
151 {
152 update((const byte*)str.c_str(), str.size());
153 }
154
155/*************************************************
156* Hashing/MACing *
157*************************************************/
158void BufferedComputation::update(byte in)
159 {
160 update(&in, 1);
161 }
162
163/*************************************************
164* Hashing/MACing *
165*************************************************/
166SecureVector<byte> BufferedComputation::final()
167 {
168 SecureVector<byte> output(OUTPUT_LENGTH);
169 final_result(output);
170 return output;
171 }
172
173/*************************************************
174* Hashing/MACing *
175*************************************************/
176SecureVector<byte> BufferedComputation::process(const byte in[], u32bit len)
177 {
178 update(in, len);
179 return final();
180 }
181
182/*************************************************
183* Hashing/MACing *
184*************************************************/
185SecureVector<byte> BufferedComputation::process(const MemoryRegion<byte>& in)
186 {
187 update(in, in.size());
188 return final();
189 }
190
191/*************************************************
192* Hashing/MACing *
193*************************************************/
194SecureVector<byte> BufferedComputation::process(const std::string& in)
195 {
196 update(in);
197 return final();
198 }
199
200/*************************************************
201* Default fast poll for EntropySources *
202*************************************************/
203u32bit EntropySource::fast_poll(byte buf[], u32bit len)
204 {
205 return slow_poll(buf, len);
206 }
207
208/*************************************************
209* Add entropy to internal state *
210*************************************************/
211void RandomNumberGenerator::add_entropy(const byte random[], u32bit length)
212 {
213 add_randomness(random, length);
214 }
215
216/*************************************************
217* Add entropy to internal state *
218*************************************************/
219void RandomNumberGenerator::add_entropy(EntropySource& source, bool slowpoll)
220 {
221 SecureVector<byte> buffer(slowpoll ? 192 : 64);
222 u32bit returned;
223
224 if(slowpoll) returned = source.slow_poll(buffer, buffer.size());
225 else returned = source.fast_poll(buffer, buffer.size());
226
227 add_entropy(buffer, returned);
228 }
229
230/*************************************************
231* Return the version as a string *
232*************************************************/
233std::string version_string()
234 {
235 return "Botan " + to_string(version_major()) + "." +
236 to_string(version_minor()) + "." +
237 to_string(version_patch());
238 }
239
240/*************************************************
241* Return parts of the version as integers *
242*************************************************/
243u32bit version_major() { return BOTAN_VERSION_MAJOR; }
244u32bit version_minor() { return BOTAN_VERSION_MINOR; }
245u32bit version_patch() { return BOTAN_VERSION_PATCH; }
246
247}

Archive Download this file

Branches

Tags

Quick Links:     www.monotone.ca    -     Downloads    -     Documentation    -     Wiki    -     Code Forge    -     Build Status