24 #if CRYPTOPP_MSC_VERSION 25 # pragma warning(disable: 4355) 28 #if CRYPTOPP_MSC_VERSION 29 # pragma warning(disable: 4505 4355) 36 const double CLOCK_TICKS_PER_SECOND = (double)CLOCKS_PER_SEC;
37 #elif defined(CLK_TCK) 38 const double CLOCK_TICKS_PER_SECOND = (double)CLK_TCK;
40 const double CLOCK_TICKS_PER_SECOND = 1000000.0;
43 const byte defaultKey[] =
"0123456789" 44 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" 45 "00000000000000000000000000000000000000000000000000000" 46 "00000000000000000000000000000000000000000000000000000";
48 double g_allocatedTime = 0.0, g_hertz = 0.0, g_logTotal = 0.0;
49 unsigned int g_logCount = 0;
50 time_t g_testBegin, g_testEnd;
52 void OutputResultBytes(
const char *name,
double length,
double timeTaken)
55 StreamState ss(std::cout);
58 if (length < 0.000001f) length = 0.000001f;
59 if (timeTaken < 0.000001f) timeTaken = 0.000001f;
61 double mbs = length / timeTaken / (1024*1024);
62 std::cout <<
"\n<TR><TD>" << name;
63 std::cout << std::setiosflags(std::ios::fixed);
64 std::cout <<
"<TD>" << std::setprecision(0) << std::setiosflags(std::ios::fixed) << mbs;
67 const double cpb = timeTaken * g_hertz / length;
69 std::cout <<
"<TD>" << std::setprecision(2) << std::setiosflags(std::ios::fixed) << cpb;
71 std::cout <<
"<TD>" << std::setprecision(1) << std::setiosflags(std::ios::fixed) << cpb;
73 g_logTotal += log(mbs);
77 void OutputResultKeying(
double iterations,
double timeTaken)
80 StreamState ss(std::cout);
83 if (iterations < 0.000001f) iterations = 0.000001f;
84 if (timeTaken < 0.000001f) timeTaken = 0.000001f;
86 std::cout <<
"<TD>" << std::setprecision(3) << std::setiosflags(std::ios::fixed) << (1000*1000*timeTaken/iterations);
90 std::cout <<
"<TD>" << std::setprecision(0) << std::setiosflags(std::ios::fixed) << timeTaken * g_hertz / iterations;
93 void OutputResultOperations(
const char *name,
const char *operation,
bool pc,
unsigned long iterations,
double timeTaken)
96 StreamState ss(std::cout);
99 if (!iterations) iterations++;
100 if (timeTaken < 0.000001f) timeTaken = 0.000001f;
102 std::cout <<
"\n<TR><TD>" << name <<
" " << operation << (pc ?
" with precomputation" :
"");
103 std::cout <<
"<TD>" << std::setprecision(2) << std::setiosflags(std::ios::fixed) << (1000*timeTaken/iterations);
108 const double t = timeTaken * g_hertz / iterations / 1000000;
109 std::cout <<
"<TD>" << std::setprecision(2) << std::setiosflags(std::ios::fixed) << t;
112 g_logTotal += log(iterations/timeTaken);
145 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
148 unsigned long i=0, blocks=1;
151 clock_t start = ::clock();
155 for (; i<blocks; i++)
157 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
159 while (timeTaken < 2.0/3*timeTotal);
161 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
169 BenchMark(name, static_cast<StreamTransformation &>(cipher), timeTotal);
174 const int BUF_SIZE=2048U;
176 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
179 unsigned long i=0, blocks=1;
182 clock_t start = ::clock();
186 for (; i<blocks; i++)
188 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
190 while (timeTaken < 2.0/3*timeTotal);
192 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
197 const int BUF_SIZE=2048U;
199 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
202 unsigned long i=0, blocks=1;
205 clock_t start = ::clock();
209 for (; i<blocks; i++)
210 bt.
Put(buf, BUF_SIZE);
211 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
213 while (timeTaken < 2.0/3*timeTotal);
215 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
220 const int BUF_SIZE = 2048U;
222 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
226 if (cipher != NULLPTR)
232 cipher->
SetKey(buf, size);
235 unsigned long long blocks = 1;
238 clock_t start = ::clock();
243 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
244 }
while (timeTaken < timeTotal);
246 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
253 void BenchMark(
const char *name,
NIST_DRBG &rng,
double timeTotal)
255 const int BUF_SIZE = 2048U;
257 Test::GlobalRNG().GenerateBlock(buf, BUF_SIZE);
261 unsigned long long blocks = 1;
264 clock_t start = ::clock();
269 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
270 }
while (timeTaken < timeTotal);
272 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
277 unsigned long iterations = 0;
280 clock_t start = ::clock();
283 for (
unsigned int i=0; i<1024; i++)
284 c.SetKey(defaultKey, keyLength, params);
285 timeTaken = double(::clock() - start) / CLOCK_TICKS_PER_SECOND;
288 while (timeTaken < g_allocatedTime);
290 OutputResultKeying(iterations, timeTaken);
293 template <
class T_FactoryOutput,
class T_Interface>
296 std::string name(factoryName ? factoryName :
"");
300 keyLength = obj->DefaultKeyLength();
305 name +=
" (" +
IntToString(keyLength * 8) +
"-bit key)";
309 BenchMark(name.c_str(), *
static_cast<T_Interface *
>(obj.get()), g_allocatedTime);
313 template <
class T_FactoryOutput>
316 CRYPTOPP_UNUSED(params);
317 BenchMarkByName2<T_FactoryOutput, T_FactoryOutput>(factoryName, keyLength, displayName, params);
323 CRYPTOPP_UNUSED(params);
324 std::string name = factoryName;
329 BenchMark(name.c_str(), *obj, g_allocatedTime);
335 std::cout <<
"<!DOCTYPE HTML>";
336 std::cout <<
"\n<HTML lang=\"en\">";
338 std::cout <<
"\n<HEAD>";
339 std::cout <<
"\n<META charset=\"UTF-8\">";
340 std::cout <<
"\n<TITLE>Speed Comparison of Popular Crypto Algorithms</TITLE>";
341 std::cout <<
"\n<STYLE>\n table {border-collapse: collapse;}";
342 std::cout <<
"\n table, th, td, tr {border: 1px solid black;}\n</STYLE>";
343 std::cout <<
"\n</HEAD>";
345 std::cout <<
"\n<BODY>";
347 std::cout <<
"\n<H1><A href=\"http://www.cryptopp.com\">Crypto++</A> " << CRYPTOPP_VERSION / 100;
348 std::cout <<
'.' << (CRYPTOPP_VERSION % 100) / 10 <<
'.' << CRYPTOPP_VERSION % 10 <<
" Benchmarks</H1>";
350 std::cout <<
"\n<P>Here are speed benchmarks for some commonly used cryptographic algorithms.</P>";
353 std::cout <<
"\n<P>CPU frequency of the test platform is " << g_hertz <<
" Hz.</P>";
355 std::cout <<
"\n<P>CPU frequency of the test platform was not provided.</P>" << std::endl;
360 std::cout <<
"\n</BODY>";
361 std::cout <<
"\n</HTML>" << std::endl;
364 void BenchmarkWithCommand(
int argc,
const char*
const argv[])
366 std::string command(argv[1]);
367 float runningTime(argc >= 3 ? Test::StringToValue<float, true>(argv[2]) : 1.0f);
368 float cpuFreq(argc >= 4 ? Test::StringToValue<float, true>(argv[3])*
float(1e9) : 0.0f);
369 std::string algoName(argc >= 5 ? argv[4] :
"");
372 Benchmark(Test::All, runningTime, cpuFreq);
373 else if (command ==
"b3")
374 Test::Benchmark(Test::PublicKey, runningTime, cpuFreq);
375 else if (command ==
"b2")
376 Test::Benchmark(Test::SharedKey, runningTime, cpuFreq);
377 else if (command ==
"b1")
378 Test::Benchmark(Test::Unkeyed, runningTime, cpuFreq);
381 void Benchmark(Test::TestClass suites,
double t,
double hertz)
388 g_testBegin = ::time(NULLPTR);
390 if (static_cast<int>(suites) == 0 || static_cast<int>(suites) > TestLast)
394 if (suites & Test::Unkeyed)
396 std::cout <<
"\n<BR>";
397 Benchmark1(t, hertz);
401 if (suites & Test::SharedKey)
403 std::cout <<
"\n<BR>";
404 Benchmark2(t, hertz);
408 if (suites & Test::PublicKey)
410 std::cout <<
"\n<BR>";
411 Benchmark3(t, hertz);
414 g_testEnd = ::time(NULLPTR);
417 StreamState state(std::cout);
418 std::cout <<
"\n<P>Throughput Geometric Average: " << std::setiosflags(std::ios::fixed);
419 std::cout << std::exp(g_logTotal/(g_logCount > 0.0f ? g_logCount : 1.0f)) << std::endl;
422 std::cout <<
"\n<P>Test started at " << TimeToString(g_testBegin);
423 std::cout <<
"\n<BR>Test ended at " << TimeToString(g_testEnd);
424 std::cout << std::endl;
429 void Benchmark1(
double t,
double hertz)
436 cpb =
"<TH>Cycles Per Byte";
440 std::cout <<
"\n<TABLE>";
442 std::cout <<
"\n<COLGROUP><COL style=\"text-align: left;\"><COL style=\"text-align: right;\">";
443 std::cout <<
"<COL style=\"text-align: right;\">";
444 std::cout <<
"\n<THEAD style=\"background: #F0F0F0\">";
445 std::cout <<
"\n<TR><TH>Algorithm<TH>MiB/Second" << cpb;
447 std::cout <<
"\n<TBODY style=\"background: white;\">";
449 #ifdef NONBLOCKING_RNG_AVAILABLE 450 BenchMarkByNameKeyLess<RandomNumberGenerator>(
"NonblockingRng");
452 #ifdef OS_RNG_AVAILABLE 453 BenchMarkByNameKeyLess<RandomNumberGenerator>(
"AutoSeededRandomPool");
454 BenchMarkByNameKeyLess<RandomNumberGenerator>(
"AutoSeededX917RNG(AES)");
456 BenchMarkByNameKeyLess<RandomNumberGenerator>(
"MT19937");
457 #if (CRYPTOPP_BOOL_X86) 459 BenchMarkByNameKeyLess<RandomNumberGenerator>(
"PadlockRNG");
461 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 463 BenchMarkByNameKeyLess<RandomNumberGenerator>(
"RDRAND");
465 BenchMarkByNameKeyLess<RandomNumberGenerator>(
"RDSEED");
467 BenchMarkByNameKeyLess<RandomNumberGenerator>(
"AES/OFB RNG");
468 BenchMarkByNameKeyLess<NIST_DRBG>(
"Hash_DRBG(SHA1)");
469 BenchMarkByNameKeyLess<NIST_DRBG>(
"Hash_DRBG(SHA256)");
470 BenchMarkByNameKeyLess<NIST_DRBG>(
"HMAC_DRBG(SHA1)");
471 BenchMarkByNameKeyLess<NIST_DRBG>(
"HMAC_DRBG(SHA256)");
474 std::cout <<
"\n<TBODY style=\"background: yellow;\">";
476 BenchMarkByNameKeyLess<HashTransformation>(
"CRC32");
477 BenchMarkByNameKeyLess<HashTransformation>(
"CRC32C");
478 BenchMarkByNameKeyLess<HashTransformation>(
"Adler32");
479 BenchMarkByNameKeyLess<HashTransformation>(
"MD5");
480 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-1");
481 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-256");
482 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-512");
483 BenchMarkByNameKeyLess<HashTransformation>(
"SHA3-224");
484 BenchMarkByNameKeyLess<HashTransformation>(
"SHA3-256");
485 BenchMarkByNameKeyLess<HashTransformation>(
"SHA3-384");
486 BenchMarkByNameKeyLess<HashTransformation>(
"SHA3-512");
487 BenchMarkByNameKeyLess<HashTransformation>(
"Keccak-224");
488 BenchMarkByNameKeyLess<HashTransformation>(
"Keccak-256");
489 BenchMarkByNameKeyLess<HashTransformation>(
"Keccak-384");
490 BenchMarkByNameKeyLess<HashTransformation>(
"Keccak-512");
491 BenchMarkByNameKeyLess<HashTransformation>(
"Tiger");
492 BenchMarkByNameKeyLess<HashTransformation>(
"Whirlpool");
493 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-160");
494 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-320");
495 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-128");
496 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-256");
497 BenchMarkByNameKeyLess<HashTransformation>(
"SM3");
498 BenchMarkByNameKeyLess<HashTransformation>(
"BLAKE2s");
499 BenchMarkByNameKeyLess<HashTransformation>(
"BLAKE2b");
502 std::cout <<
"\n</TABLE>" << std::endl;
505 void Benchmark2(
double t,
double hertz)
510 const char *cpb, *cpk;
513 cpb =
"<TH>Cycles Per Byte";
514 cpk =
"<TH>Cycles to<BR>Setup Key and IV";
521 std::cout <<
"\n<TABLE>";
522 std::cout <<
"\n<COLGROUP><COL style=\"text-align: left;\"><COL style=\"text-align: right;\"><COL style=";
523 std::cout <<
"\"text-align: right;\"><COL style=\"text-align: right;\"><COL style=\"text-align: right;\">";
524 std::cout <<
"\n<THEAD style=\"background: #F0F0F0\">";
525 std::cout <<
"\n<TR><TH>Algorithm<TH>MiB/Second" << cpb;
526 std::cout <<
"<TH>Microseconds to<BR>Setup Key and IV" << cpk;
528 std::cout <<
"\n<TBODY style=\"background: white;\">";
530 #if CRYPTOPP_AESNI_AVAILABLE 532 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES)");
534 #elif CRYPTOPP_ARM_PMULL_AVAILABLE 536 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES)");
540 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES) (2K tables)",
MakeParameters(
Name::TableSize(), 2048));
541 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES) (64K tables)",
MakeParameters(
Name::TableSize(), 64 * 1024));
544 BenchMarkByName<MessageAuthenticationCode>(
"VMAC(AES)-64");
545 BenchMarkByName<MessageAuthenticationCode>(
"VMAC(AES)-128");
546 BenchMarkByName<MessageAuthenticationCode>(
"HMAC(SHA-1)");
547 BenchMarkByName<MessageAuthenticationCode>(
"HMAC(SHA-256)");
548 BenchMarkByName<MessageAuthenticationCode>(
"Two-Track-MAC");
549 BenchMarkByName<MessageAuthenticationCode>(
"CMAC(AES)");
550 BenchMarkByName<MessageAuthenticationCode>(
"DMAC(AES)");
551 BenchMarkByName<MessageAuthenticationCode>(
"Poly1305(AES)");
552 BenchMarkByName<MessageAuthenticationCode>(
"BLAKE2s");
553 BenchMarkByName<MessageAuthenticationCode>(
"BLAKE2b");
554 BenchMarkByName<MessageAuthenticationCode>(
"SipHash-2-4");
555 BenchMarkByName<MessageAuthenticationCode>(
"SipHash-4-8");
558 std::cout <<
"\n<TBODY style=\"background: yellow;\">";
560 BenchMarkByName<SymmetricCipher>(
"Panama-LE");
561 BenchMarkByName<SymmetricCipher>(
"Panama-BE");
562 BenchMarkByName<SymmetricCipher>(
"Salsa20");
565 BenchMarkByName<SymmetricCipher>(
"ChaCha20");
566 BenchMarkByName<SymmetricCipher>(
"ChaCha12");
567 BenchMarkByName<SymmetricCipher>(
"ChaCha8");
568 BenchMarkByName<SymmetricCipher>(
"Sosemanuk");
569 BenchMarkByName<SymmetricCipher>(
"MARC4");
570 BenchMarkByName<SymmetricCipher>(
"SEAL-3.0-LE");
571 BenchMarkByName<SymmetricCipher>(
"WAKE-OFB-LE");
574 std::cout <<
"\n<TBODY style=\"background: white;\">";
576 BenchMarkByName<SymmetricCipher>(
"AES/CTR", 16);
577 BenchMarkByName<SymmetricCipher>(
"AES/CTR", 24);
578 BenchMarkByName<SymmetricCipher>(
"AES/CTR", 32);
579 BenchMarkByName<SymmetricCipher>(
"AES/CBC", 16);
580 BenchMarkByName<SymmetricCipher>(
"AES/CBC", 24);
581 BenchMarkByName<SymmetricCipher>(
"AES/CBC", 32);
582 BenchMarkByName<SymmetricCipher>(
"AES/OFB", 16);
583 BenchMarkByName<SymmetricCipher>(
"AES/CFB", 16);
584 BenchMarkByName<SymmetricCipher>(
"AES/ECB", 16);
585 BenchMarkByName<SymmetricCipher>(
"ARIA/CTR", 16);
586 BenchMarkByName<SymmetricCipher>(
"ARIA/CTR", 32);
587 BenchMarkByName<SymmetricCipher>(
"Camellia/CTR", 16);
588 BenchMarkByName<SymmetricCipher>(
"Camellia/CTR", 32);
589 BenchMarkByName<SymmetricCipher>(
"Twofish/CTR");
590 BenchMarkByName<SymmetricCipher>(
"Threefish-256(256)/CTR", 32);
591 BenchMarkByName<SymmetricCipher>(
"Threefish-512(512)/CTR", 64);
592 BenchMarkByName<SymmetricCipher>(
"Threefish-1024(1024)/CTR", 128);
593 BenchMarkByName<SymmetricCipher>(
"Serpent/CTR");
594 BenchMarkByName<SymmetricCipher>(
"CAST-128/CTR");
595 BenchMarkByName<SymmetricCipher>(
"CAST-256/CTR");
596 BenchMarkByName<SymmetricCipher>(
"RC6/CTR");
597 BenchMarkByName<SymmetricCipher>(
"MARS/CTR");
598 BenchMarkByName<SymmetricCipher>(
"SHACAL-2/CTR", 16);
599 BenchMarkByName<SymmetricCipher>(
"SHACAL-2/CTR", 64);
600 BenchMarkByName<SymmetricCipher>(
"DES/CTR");
601 BenchMarkByName<SymmetricCipher>(
"DES-XEX3/CTR");
602 BenchMarkByName<SymmetricCipher>(
"DES-EDE3/CTR");
603 BenchMarkByName<SymmetricCipher>(
"IDEA/CTR");
604 BenchMarkByName<SymmetricCipher>(
"RC5/CTR", 0,
"RC5 (r=16)");
605 BenchMarkByName<SymmetricCipher>(
"Blowfish/CTR");
606 BenchMarkByName<SymmetricCipher>(
"TEA/CTR");
607 BenchMarkByName<SymmetricCipher>(
"XTEA/CTR");
608 BenchMarkByName<SymmetricCipher>(
"SKIPJACK/CTR");
609 BenchMarkByName<SymmetricCipher>(
"SEED/CTR", 0,
"SEED/CTR (1/2 K table)");
610 BenchMarkByName<SymmetricCipher>(
"SM4/CTR");
612 BenchMarkByName<SymmetricCipher>(
"Kalyna-128/CTR", 16,
"Kalyna-128(128)/CTR (128-bit key)");
613 BenchMarkByName<SymmetricCipher>(
"Kalyna-128/CTR", 32,
"Kalyna-128(256)/CTR (256-bit key)");
614 BenchMarkByName<SymmetricCipher>(
"Kalyna-256/CTR", 32,
"Kalyna-256(256)/CTR (256-bit key)");
615 BenchMarkByName<SymmetricCipher>(
"Kalyna-256/CTR", 64,
"Kalyna-256(512)/CTR (512-bit key)");
616 BenchMarkByName<SymmetricCipher>(
"Kalyna-512/CTR", 64,
"Kalyna-512(512)/CTR (512-bit key)");
618 BenchMarkByName<SymmetricCipher>(
"SIMON-64/CTR", 12,
"SIMON-64(96)/CTR (96-bit key)");
619 BenchMarkByName<SymmetricCipher>(
"SIMON-64/CTR", 16,
"SIMON-64(128)/CTR (128-bit key)");
620 BenchMarkByName<SymmetricCipher>(
"SIMON-128/CTR", 16,
"SIMON-128(128)/CTR (128-bit key)");
621 BenchMarkByName<SymmetricCipher>(
"SIMON-128/CTR", 24,
"SIMON-128(192)/CTR (192-bit key)");
622 BenchMarkByName<SymmetricCipher>(
"SIMON-128/CTR", 32,
"SIMON-128(256)/CTR (256-bit key)");
624 BenchMarkByName<SymmetricCipher>(
"SPECK-64/CTR", 12,
"SPECK-64(96)/CTR (96-bit key)");
625 BenchMarkByName<SymmetricCipher>(
"SPECK-64/CTR", 16,
"SPECK-64(128)/CTR (128-bit key)");
626 BenchMarkByName<SymmetricCipher>(
"SPECK-128/CTR", 16,
"SPECK-128(128)/CTR (128-bit key)");
627 BenchMarkByName<SymmetricCipher>(
"SPECK-128/CTR", 24,
"SPECK-128(192)/CTR (192-bit key)");
628 BenchMarkByName<SymmetricCipher>(
"SPECK-128/CTR", 32,
"SPECK-128(256)/CTR (256-bit key)");
631 std::cout <<
"\n<TBODY style=\"background: yellow;\">";
633 #if CRYPTOPP_AESNI_AVAILABLE 635 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM");
637 #elif CRYPTOPP_ARM_PMULL_AVAILABLE 639 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM");
643 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM (2K tables)",
MakeParameters(
Name::TableSize(), 2048));
644 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM (64K tables)",
MakeParameters(
Name::TableSize(), 64 * 1024));
646 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/CCM");
647 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/EAX");
650 std::cout <<
"\n</TABLE>" << std::endl;
Used to pass byte array input as part of a NameValuePairs object.
int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
virtual bool NeedsPrespecifiedDataLengths() const
Determines if data lengths must be specified prior to inputting data.
virtual void SetKey(const byte *key, size_t length, const NameValuePairs ¶ms=g_nullNameValuePairs)
Sets or reset the key of this object.
Classes for NIST DRBGs from SP 800-90A.
virtual void GenerateBlock(byte *output, size_t size)=0
Generate random array of bytes.
Interface for authenticated encryption modes of operation.
Classes for block cipher modes of operation.
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
Classes for VIA Padlock RNG.
bool HasPadlockRNG()
Determines Padlock RNG availability.
Abstract base classes that provide a uniform interface to this library.
virtual unsigned int MinEntropyLength() const =0
Provides the minimum entropy size.
Classes for automatic resource management.
Interface for random number generators.
Classes for RDRAND and RDSEED.
Combines two sets of NameValuePairs.
virtual size_t DefaultKeyLength() const =0
Returns default key length.
bool HasRDRAND()
Determines RDRAND availability.
Pointer that overloads operator ->
const char * TableSize()
int, in bytes
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Classes for HexEncoder and HexDecoder.
bool HasRDSEED()
Determines RDSEED availability.
bool HasCLMUL()
Determines Carryless Multiply availability.
Class file for the AES cipher (Rijndael)
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode...
Interface for algorithms that take byte strings as keys.
Namespace containing testing and benchmark classes.
Classes for the Threefish block cipher.
SecBlock using AllocatorWithCleanup<byte, true> typedef.
Classes and functions for registering and locating library objects.
Classes for the Kalyna block cipher.
const char * BlockSize()
int, in bytes
Functions for CPU features and intrinsics.
virtual void IncorporateEntropy(const byte *input, size_t length)=0
Update RNG state with additional unpredictable values.
Implementation of BufferedTransformation's attachment interface.
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
virtual lword MaxMessageLength() const =0
Provides the maximum length of encrypted data.
void SetKeyWithIV(const byte *key, size_t length, const byte *iv, size_t ivLength)
Sets or reset the key of this object.
const NameValuePairs g_nullNameValuePairs
An empty set of name-value pairs.
Interface for NIST DRBGs from SP 800-90A.
Classes for Blum Blum Shub generator.
std::string IntToString(T value, unsigned int base=10)
Converts a value to a string.
T1 RoundUpToMultipleOf(const T1 &n, const T2 &m)
Rounds a value up to a multiple of a second value.
Classes providing file-based library services.
void SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0)
Prespecifies the data lengths.
Crypto++ library namespace.
bool IsResynchronizable() const
Determines if the object can be resynchronized.
bool HasPMULL()
Determine if an ARM processor provides Polynomial Multiplication.
Interface for retrieving values given their names.