Crypto++ 8.9 Free C++ class library of cryptographic schemes

bench1.cpp
1 // bench1.cpp - originally written and placed in the public domain by Wei Dai
2 // CryptoPP::Test namespace added by JW in February 2017
3
4 #include "cryptlib.h"
5 #include "bench.h"
6 #include "validate.h"
7
8 #include "cpu.h"
9 #include "factory.h"
10 #include "algparam.h"
11 #include "argnames.h"
12 #include "smartptr.h"
13 #include "stdcpp.h"
14
15 #include "osrng.h"
16 #include "drbg.h"
17 #include "darn.h"
18 #include "mersenne.h"
19 #include "rdrand.h"
20 #include "padlkrng.h"
21
22 #include <iostream>
23 #include <iomanip>
24 #include <sstream>
25
26 #if CRYPTOPP_MSC_VERSION
27 # pragma warning(disable: 4355)
28 #endif
29
30 #if CRYPTOPP_MSC_VERSION
31 # pragma warning(disable: 4505 4355)
32 #endif
33
34 NAMESPACE_BEGIN(CryptoPP)
35 NAMESPACE_BEGIN(Test)
36
37 #ifdef CLOCKS_PER_SEC
38 const double CLOCK_TICKS_PER_SECOND = (double)CLOCKS_PER_SEC;
39 #elif defined(CLK_TCK)
40 const double CLOCK_TICKS_PER_SECOND = (double)CLK_TCK;
41 #else
42 const double CLOCK_TICKS_PER_SECOND = 1000000.0;
43 #endif
44
45 extern const byte defaultKey[] = "0123456789" // 168 + NULL
46 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
47 "00000000000000000000000000000000000000000000000000000"
48 "00000000000000000000000000000000000000000000000000000";
49
50 double g_allocatedTime = 0.0, g_hertz = 0.0, g_logTotal = 0.0;
51 unsigned int g_logCount = 0;
52 time_t g_testBegin, g_testEnd;
53
54 inline std::string HertzToString(double hertz)
55 {
56 std::ostringstream oss;
57 oss.precision(3);
58
59 if (hertz >= 0.999e+9)
60 oss << hertz / 1e+9 << " GHz";
61 else if (hertz >= 0.999e+6)
62 oss << hertz / 1e+6 << " MHz";
63 else if (hertz >= 0.999e+3)
64 oss << hertz / 1e+3 << " KHz";
65 else
66 oss << hertz << " Hz";
67
68 return oss.str();
69 }
70
71 void OutputResultBytes(const char *name, const char *provider, double length, double timeTaken)
72 {
73 std::ostringstream oss;
74
75 // Coverity finding
76 if (length < 0.000001f) length = 0.000001f;
77 if (timeTaken < 0.000001f) timeTaken = 0.000001f;
78
79 double mbs = length / timeTaken / (1024*1024);
80 oss << "\n<TR><TD>" << name << "<TD>" << provider;
81 oss << std::setiosflags(std::ios::fixed);
82 oss << "<TD>" << std::setprecision(0) << std::setiosflags(std::ios::fixed) << mbs;
83 if (g_hertz > 1.0f)
84 {
85 const double cpb = timeTaken * g_hertz / length;
86 if (cpb < 24.0f)
87 oss << "<TD>" << std::setprecision(2) << std::setiosflags(std::ios::fixed) << cpb;
88 else
89 oss << "<TD>" << std::setprecision(1) << std::setiosflags(std::ios::fixed) << cpb;
90 }
91 g_logTotal += log(mbs);
92 g_logCount++;
93
94 std::cout << oss.str();
95 }
96
97 void OutputResultKeying(double iterations, double timeTaken)
98 {
99 std::ostringstream oss;
100
101 // Coverity finding
102 if (iterations < 0.000001f) iterations = 0.000001f;
103 if (timeTaken < 0.000001f) timeTaken = 0.000001f;
104
105 oss << "<TD>" << std::setprecision(3) << std::setiosflags(std::ios::fixed) << (1000*1000*timeTaken/iterations);
106
107 // Coverity finding
108 if (g_hertz > 1.0f)
109 oss << "<TD>" << std::setprecision(0) << std::setiosflags(std::ios::fixed) << timeTaken * g_hertz / iterations;
110
111 std::cout << oss.str();
112 }
113
114 void OutputResultOperations(const char *name, const char *provider, const char *operation, bool pc, unsigned long iterations, double timeTaken)
115 {
116 CRYPTOPP_UNUSED(provider);
117 std::ostringstream oss;
118
119 // Coverity finding
120 if (!iterations) iterations++;
121 if (timeTaken < 0.000001f) timeTaken = 0.000001f;
122
123 oss << "\n<TR><TD>" << name << " " << operation << (pc ? " with precomputation" : "");
124 //oss << "<TD>" << provider;
125 oss << "<TD>" << std::setprecision(3) << std::setiosflags(std::ios::fixed) << (1000*timeTaken/iterations);
126
127 // Coverity finding
128 if (g_hertz > 1.0f)
129 {
130 const double t = timeTaken * g_hertz / iterations / 1000000;
131 oss << "<TD>" << std::setprecision(3) << std::setiosflags(std::ios::fixed) << t;
132 }
133
134 g_logTotal += log(iterations/timeTaken);
135 g_logCount++;
136
137 std::cout << oss.str();
138 }
139
140 /*
141 void BenchMark(const char *name, BlockTransformation &cipher, double timeTotal)
142 {
143 const int BUF_SIZE = RoundUpToMultipleOf(2048U, cipher.OptimalNumberOfParallelBlocks() * cipher.BlockSize());
144 AlignedSecByteBlock buf(BUF_SIZE);
145 buf.SetMark(16);
146
147 const int nBlocks = BUF_SIZE / cipher.BlockSize();
148 unsigned long i=0, blocks=1;
149 double timeTaken;
150
151 clock_t start = ::clock();
152 do
153 {
154 blocks *= 2;
155 for (; i<blocks; i++)
156 cipher.ProcessAndXorMultipleBlocks(buf, NULLPTR, buf, nBlocks);
157 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
158 }
159 while (timeTaken < 2.0/3*timeTotal);
160
161 OutputResultBytes(name, double(blocks) * BUF_SIZE, timeTaken);
162 }
163 */
164
165 void BenchMark(const char *name, StreamTransformation &cipher, double timeTotal)
166 {
167 const int BUF_SIZE=RoundUpToMultipleOf(2048U, cipher.OptimalBlockSize());
168 AlignedSecByteBlock buf(BUF_SIZE);
169 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
170 buf.SetMark(16);
171
172 unsigned long i=0, blocks=1;
173 double timeTaken;
174
175 clock_t start = ::clock();
176 do
177 {
178 blocks *= 2;
179 for (; i<blocks; i++)
180 cipher.ProcessString(buf, BUF_SIZE);
181 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
182 }
183 while (timeTaken < 2.0/3*timeTotal);
184
185 std::string provider = cipher.AlgorithmProvider();
186 OutputResultBytes(name, provider.c_str(), double(blocks) * BUF_SIZE, timeTaken);
187 }
188
189 void BenchMark(const char *name, HashTransformation &ht, double timeTotal)
190 {
191 const int BUF_SIZE=2048U;
192 AlignedSecByteBlock buf(BUF_SIZE);
193 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
194 buf.SetMark(16);
195
196 unsigned long i=0, blocks=1;
197 double timeTaken;
198
199 clock_t start = ::clock();
200 do
201 {
202 blocks *= 2;
203 for (; i<blocks; i++)
204 ht.Update(buf, BUF_SIZE);
205 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
206 }
207 while (timeTaken < 2.0/3*timeTotal);
208
209 std::string provider = ht.AlgorithmProvider();
210 OutputResultBytes(name, provider.c_str(), double(blocks) * BUF_SIZE, timeTaken);
211 }
212
213 void BenchMark(const char *name, BufferedTransformation &bt, double timeTotal)
214 {
215 const int BUF_SIZE=2048U;
216 AlignedSecByteBlock buf(BUF_SIZE);
217 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
218 buf.SetMark(16);
219
220 unsigned long i=0, blocks=1;
221 double timeTaken;
222
223 clock_t start = ::clock();
224 do
225 {
226 blocks *= 2;
227 for (; i<blocks; i++)
228 bt.Put(buf, BUF_SIZE);
229 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
230 }
231 while (timeTaken < 2.0/3*timeTotal);
232
233 std::string provider = bt.AlgorithmProvider();
234 OutputResultBytes(name, provider.c_str(), double(blocks) * BUF_SIZE, timeTaken);
235 }
236
237 void BenchMark(const char *name, RandomNumberGenerator &rng, double timeTotal)
238 {
239 const int BUF_SIZE = 2048U;
240 AlignedSecByteBlock buf(BUF_SIZE);
241 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
242 buf.SetMark(16);
243
244 SymmetricCipher * cipher = dynamic_cast<SymmetricCipher*>(&rng);
245 if (cipher != NULLPTR)
246 {
247 const size_t size = cipher->DefaultKeyLength();
248 if (cipher->IsResynchronizable())
249 cipher->SetKeyWithIV(buf, size, buf+size);
250 else
251 cipher->SetKey(buf, size);
252 }
253
254 unsigned long long blocks = 1;
255 double timeTaken;
256
257 clock_t start = ::clock();
258 do
259 {
260 rng.GenerateBlock(buf, buf.size());
261 blocks++;
262 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
263 } while (timeTaken < timeTotal);
264
265 std::string provider = rng.AlgorithmProvider();
266 OutputResultBytes(name, provider.c_str(), double(blocks) * BUF_SIZE, timeTaken);
267 }
268
269 // Hack, but we probably need a KeyedRandomNumberGenerator interface
270 // and a few methods to generalize keying a RNG. X917RNG, Hash_DRBG,
271 // HMAC_DRBG, AES/CFB RNG and a few others could use it. "A few others"
272 // includes BLAKE2, ChaCha and Poly1305 when used as a RNG.
273 void BenchMark(const char *name, NIST_DRBG &rng, double timeTotal)
274 {
275 const int BUF_SIZE = 2048U;
276 AlignedSecByteBlock buf(BUF_SIZE);
277 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
278 buf.SetMark(16);
279
280 rng.IncorporateEntropy(buf, rng.MinEntropyLength());
281 unsigned long long blocks = 1;
282 double timeTaken;
283
284 clock_t start = ::clock();
285 do
286 {
287 rng.GenerateBlock(buf, buf.size());
288 blocks++;
289 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
290 } while (timeTaken < timeTotal);
291
292 std::string provider = rng.AlgorithmProvider();
293 OutputResultBytes(name, provider.c_str(), double(blocks) * BUF_SIZE, timeTaken);
294 }
295
296 template <class T>
297 void BenchMarkByNameKeyLess(const char *factoryName, const char *displayName = NULLPTR, const NameValuePairs &params = g_nullNameValuePairs)
298 {
299 CRYPTOPP_UNUSED(params);
300 std::string name = factoryName;
301 if (displayName)
302 name = displayName;
303
304 member_ptr<T> obj(ObjectFactoryRegistry<T>::Registry().CreateObject(factoryName));
305 BenchMark(name.c_str(), *obj, g_allocatedTime);
306 }
307
308 void AddHtmlHeader()
309 {
310 std::ostringstream oss;
311
312 // HTML5
313 oss << "<!DOCTYPE HTML>";
314 oss << "\n<HTML lang=\"en\">";
315
316 oss << "\n<HEAD>";
317 oss << "\n<META charset=\"UTF-8\">";
318 oss << "\n<TITLE>Speed Comparison of Popular Crypto Algorithms</TITLE>";
319 oss << "\n<STYLE>\n table {border-collapse: collapse;}";
320 oss << "\n table, th, td, tr {border: 1px solid black;}\n</STYLE>";
321 oss << "\n</HEAD>";
322
323 oss << "\n<BODY>";
324
325 oss << "\n<H1><A href=\"http://www.cryptopp.com\">Crypto++ " << CRYPTOPP_VERSION / 100;
326 oss << '.' << (CRYPTOPP_VERSION % 100) / 10 << '.' << CRYPTOPP_VERSION % 10 << "</A> Benchmarks</H1>";
327
328 oss << "\n<P>Here are speed benchmarks for some commonly used cryptographic algorithms.</P>";
329
330 if (g_hertz > 1.0f)
331 oss << "\n<P>CPU frequency of the test platform is " << HertzToString(g_hertz) << ".</P>";
332 else
333 oss << "\n<P>CPU frequency of the test platform was not provided.</P>" << std::endl;
334
335 std::cout << oss.str();
336 }
337
338 void AddHtmlFooter()
339 {
340 std::ostringstream oss;
341 oss << "\n</BODY>\n</HTML>\n";
342 std::cout << oss.str();
343 }
344
345 void BenchmarkWithCommand(int argc, const char* const argv[])
346 {
347 std::string command(argv[1]);
348 float runningTime(argc >= 3 ? Test::StringToValue<float, true>(argv[2]) : 1.0f);
349 float cpuFreq(argc >= 4 ? Test::StringToValue<float, true>(argv[3])*float(1e9) : 0.0f);
350 std::string algoName(argc >= 5 ? argv[4] : "");
351
352 // https://github.com/weidai11/cryptopp/issues/983
353 if (runningTime > 10.0f)
354 runningTime = 10.0f;
355
356 if (command == "b") // All benchmarks
357 Benchmark(Test::All, runningTime, cpuFreq);
358 else if (command == "b4") // Public key algorithms over EC
359 Test::Benchmark(Test::PublicKeyEC, runningTime, cpuFreq);
360 else if (command == "b3") // Public key algorithms
361 Test::Benchmark(Test::PublicKey, runningTime, cpuFreq);
362 else if (command == "b2") // Shared key algorithms
363 Test::Benchmark(Test::SharedKey, runningTime, cpuFreq);
364 else if (command == "b1") // Unkeyed algorithms
365 Test::Benchmark(Test::Unkeyed, runningTime, cpuFreq);
366 }
367
368 void Benchmark(Test::TestClass suites, double t, double hertz)
369 {
370 g_allocatedTime = t;
371 g_hertz = hertz;
372
373 // Add <br> in between tables
374 size_t count_breaks = 0;
375
376 AddHtmlHeader();
377
378 g_testBegin = ::time(NULLPTR);
379
380 if (static_cast<int>(suites) == 0 || static_cast<int>(suites) > TestLast)
381 suites = Test::All;
382
383 // Unkeyed algorithms
384 if (suites & Test::Unkeyed)
385 {
386 if (count_breaks)
387 std::cout << "\n<BR>";
388 count_breaks++;
389
390 BenchmarkUnkeyedAlgorithms(t, hertz);
391 }
392
393 // Shared key algorithms
394 if (suites & Test::SharedKey)
395 {
396 if (count_breaks)
397 std::cout << "\n<BR>";
398 count_breaks++;
399
400 BenchmarkSharedKeyedAlgorithms(t, hertz);
401 }
402
403 // Public key algorithms
404 if (suites & Test::PublicKey)
405 {
406 if (count_breaks)
407 std::cout << "\n<BR>";
408 count_breaks++;
409
410 BenchmarkPublicKeyAlgorithms(t, hertz);
411 }
412
413 // Public key algorithms over EC
414 if (suites & Test::PublicKeyEC)
415 {
416 if (count_breaks)
417 std::cout << "\n<BR>";
418 count_breaks++;
419
420 BenchmarkEllipticCurveAlgorithms(t, hertz);
421 }
422
423 g_testEnd = ::time(NULLPTR);
424
425 std::ostringstream oss;
426 oss << "\n<P>Throughput Geometric Average: " << std::setiosflags(std::ios::fixed);
427 oss << std::exp(g_logTotal/(g_logCount > 0.0f ? g_logCount : 1.0f)) << std::endl;
428
429 oss << "\n<P>Test started at " << TimeToString(g_testBegin);
430 oss << "\n<BR>Test ended at " << TimeToString(g_testEnd);
431 oss << "\n";
432 std::cout << oss.str();
433
434 AddHtmlFooter();
435 }
436
437 void BenchmarkUnkeyedAlgorithms(double t, double hertz)
438 {
439 g_allocatedTime = t;
440 g_hertz = hertz;
441
442 const char *cpb;
443 if (g_hertz > 1.0f)
444 cpb = "<TH>Cycles/Byte";
445 else
446 cpb = "";
447
448 std::cout << "\n<TABLE>";
449
450 std::cout << "\n<COLGROUP><COL style=\"text-align: left;\"><COL style=\"text-align: right;\">";
451 std::cout << "<COL style=\"text-align: right;\">";
452 std::cout << "\n<THEAD style=\"background: #F0F0F0\">";
453 std::cout << "\n<TR><TH>Algorithm<TH>Provider<TH>MiB/Second" << cpb;
454
455 std::cout << "\n<TBODY style=\"background: white;\">";
456 {
457 #ifdef NONBLOCKING_RNG_AVAILABLE
458 BenchMarkByNameKeyLess<RandomNumberGenerator>("NonblockingRng");
459 #endif
460 #ifdef OS_RNG_AVAILABLE
461 BenchMarkByNameKeyLess<RandomNumberGenerator>("AutoSeededRandomPool");
462 BenchMarkByNameKeyLess<RandomNumberGenerator>("AutoSeededX917RNG(AES)");
463 #endif
464 BenchMarkByNameKeyLess<RandomNumberGenerator>("MT19937");
465 #if (CRYPTOPP_BOOL_X86) && !defined(CRYPTOPP_DISABLE_ASM)
466 if (HasPadlockRNG())
467 BenchMarkByNameKeyLess<RandomNumberGenerator>("PadlockRNG");
468 #endif
469 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) && !defined(CRYPTOPP_DISABLE_ASM)
470 if (HasRDRAND())
471 BenchMarkByNameKeyLess<RandomNumberGenerator>("RDRAND");
472 if (HasRDSEED())
473 BenchMarkByNameKeyLess<RandomNumberGenerator>("RDSEED");
474 #endif
475 #if (CRYPTOPP_BOOL_PPC32 || CRYPTOPP_BOOL_PPC64) && !defined(CRYPTOPP_DISABLE_ASM)
476 if (HasDARN())
477 BenchMarkByNameKeyLess<RandomNumberGenerator>("DARN");
478 #endif
479 BenchMarkByNameKeyLess<RandomNumberGenerator>("AES/OFB RNG");
480 BenchMarkByNameKeyLess<NIST_DRBG>("Hash_DRBG(SHA1)");
481 BenchMarkByNameKeyLess<NIST_DRBG>("Hash_DRBG(SHA256)");
482 BenchMarkByNameKeyLess<NIST_DRBG>("HMAC_DRBG(SHA1)");
483 BenchMarkByNameKeyLess<NIST_DRBG>("HMAC_DRBG(SHA256)");
484 }
485
486 std::cout << "\n<TBODY style=\"background: yellow;\">";
487 {
488 BenchMarkByNameKeyLess<HashTransformation>("CRC32");
489 BenchMarkByNameKeyLess<HashTransformation>("CRC32C");
490 BenchMarkByNameKeyLess<HashTransformation>("Adler32");
491 BenchMarkByNameKeyLess<HashTransformation>("MD5");
492 BenchMarkByNameKeyLess<HashTransformation>("SHA-1");
493 BenchMarkByNameKeyLess<HashTransformation>("SHA-256");
494 BenchMarkByNameKeyLess<HashTransformation>("SHA-512");
495 BenchMarkByNameKeyLess<HashTransformation>("SHA3-224");
496 BenchMarkByNameKeyLess<HashTransformation>("SHA3-256");
497 BenchMarkByNameKeyLess<HashTransformation>("SHA3-384");
498 BenchMarkByNameKeyLess<HashTransformation>("SHA3-512");
499 BenchMarkByNameKeyLess<HashTransformation>("Keccak-224");
500 BenchMarkByNameKeyLess<HashTransformation>("Keccak-256");
501 BenchMarkByNameKeyLess<HashTransformation>("Keccak-384");
502 BenchMarkByNameKeyLess<HashTransformation>("Keccak-512");
503 BenchMarkByNameKeyLess<HashTransformation>("Tiger");
504 BenchMarkByNameKeyLess<HashTransformation>("Whirlpool");
505 BenchMarkByNameKeyLess<HashTransformation>("RIPEMD-160");
506 BenchMarkByNameKeyLess<HashTransformation>("RIPEMD-320");
507 BenchMarkByNameKeyLess<HashTransformation>("RIPEMD-128");
508 BenchMarkByNameKeyLess<HashTransformation>("RIPEMD-256");
509 BenchMarkByNameKeyLess<HashTransformation>("SM3");
510 BenchMarkByNameKeyLess<HashTransformation>("BLAKE2s");
511 BenchMarkByNameKeyLess<HashTransformation>("BLAKE2b");
512 BenchMarkByNameKeyLess<HashTransformation>("LSH-256");
513 BenchMarkByNameKeyLess<HashTransformation>("LSH-512");
514 }
515
516 std::cout << "\n</TABLE>" << std::endl;
517 }
518
519 NAMESPACE_END // Test
520 NAMESPACE_END // CryptoPP
algparam.h
Classes for working with NameValuePairs.
argnames.h
Standard names for retrieving values by name when working with NameValuePairs.
Algorithm::AlgorithmProvider
virtual std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
Definition: cryptlib.h:641
AlignedSecByteBlock
SecBlock using AllocatorWithCleanup<byte, true> typedef.
Definition: secblock.h:1230
BufferedTransformation
Interface for buffered transformations.
Definition: cryptlib.h:1657
BufferedTransformation::Put
size_t Put(byte inByte, bool blocking=true)
Input a byte for processing.
Definition: cryptlib.h:1678
HashTransformation
Interface for hash functions and data processing part of MACs.
Definition: cryptlib.h:1118
HashTransformation::Update
virtual void Update(const byte *input, size_t length)=0
Updates a hash with additional input.
NIST_DRBG
Interface for NIST DRBGs from SP 800-90A.
Definition: drbg.h:27
NIST_DRBG::IncorporateEntropy
virtual void IncorporateEntropy(const byte *input, size_t length)=0
Update RNG state with additional unpredictable values.
NIST_DRBG::GenerateBlock
virtual void GenerateBlock(byte *output, size_t size)=0
Generate random array of bytes.
NIST_DRBG::MinEntropyLength
virtual unsigned int MinEntropyLength() const =0
Provides the minimum entropy size.
NameValuePairs
Interface for retrieving values given their names.
Definition: cryptlib.h:327
ObjectFactoryRegistry
Object factory registry.
Definition: factory.h:43
RandomNumberGenerator
Interface for random number generators.
Definition: cryptlib.h:1440
RandomNumberGenerator::GenerateBlock
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
SimpleKeyingInterface::SetKeyWithIV
void SetKeyWithIV(const byte *key, size_t length, const byte *iv, size_t ivLength)
Sets or reset the key of this object.
SimpleKeyingInterface::IsResynchronizable
bool IsResynchronizable() const
Determines if the object can be resynchronized.
Definition: cryptlib.h:745
SimpleKeyingInterface::SetKey
virtual void SetKey(const byte *key, size_t length, const NameValuePairs &params=g_nullNameValuePairs)
Sets or reset the key of this object.
SimpleKeyingInterface::DefaultKeyLength
virtual size_t DefaultKeyLength() const =0
Returns default key length.
StreamTransformation
Interface for the data processing portion of stream ciphers.
Definition: cryptlib.h:951
StreamTransformation::ProcessString
void ProcessString(byte *inoutString, size_t length)
Encrypt or decrypt a string of bytes.
Definition: cryptlib.h:1065
StreamTransformation::OptimalBlockSize
virtual unsigned int OptimalBlockSize() const
Provides the input block size most efficient for this cipher.
Definition: cryptlib.h:977
SymmetricCipher
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode.
Definition: cryptlib.h:1296
member_ptr
Pointer that overloads operator ->
Definition: smartptr.h:38
CRYPTOPP_VERSION
#define CRYPTOPP_VERSION
Full library version.
Definition: config_ver.h:53
cpu.h
Functions for CPU features and intrinsics.
cryptlib.h
Abstract base classes that provide a uniform interface to this library.
g_nullNameValuePairs
const NameValuePairs & g_nullNameValuePairs
An empty set of name-value pairs.
Definition: cryptlib.h:534
darn.h
Classes for DARN RNG.
drbg.h
Classes for NIST DRBGs from SP 800-90A.
factory.h
Classes and functions for registering and locating library objects.
mersenne.h
Class file for Mersenne Twister.
RoundUpToMultipleOf
T1 RoundUpToMultipleOf(const T1 &n, const T2 &m)
Rounds a value up to a multiple of a second value.
Definition: misc.h:1384
CryptoPP
Crypto++ library namespace.
Test
Namespace containing testing and benchmark classes.
Definition: cryptlib.h:580
osrng.h
Classes for access to the operating system's random number generators.
padlkrng.h
Classes for VIA Padlock RNG.
rdrand.h
Classes for RDRAND and RDSEED.
smartptr.h
Classes for automatic resource management.
stdcpp.h
Common C++ header files.